World's first open-source enterprise world model.
Rust agent-memorybitemporalgraphragknowledge-baseknowledge-graphllmontologypgvectorpostgresqlragrustself-hostedsemantic-searchtemporal-knowledge-graphworld-model
A fact quotes the words that name each side (#583)
WaylandYang44d16fac9cb8
diff --git a/crates/utopia-extract/src/lib.rs b/crates/utopia-extract/src/lib.rsindex 6fa3ad5e..6478789d 100644--- a/crates/utopia-extract/src/lib.rs+++ b/crates/utopia-extract/src/lib.rs@@ -67,6 +67,13 @@ pub struct ExtractedFact {pub confidence: Option<f32>,#[serde(default)]pub quote: Option<String>,+ /// 引文里逐字点名主语的那几个字(#582)。模型抄,不判断;落库时机器核对它+ /// 是不是 `subject` 那个名字——"Former OpenAI personnel" 不是 OpenAI+ #[serde(default)]+ pub subject_span: Option<String>,+ /// 同上,宾语那一侧+ #[serde(default)]+ pub object_span: Option<String>,}/// 提示词里的一条关系。@@ -243,7 +250,7 @@ pub fn build_messages(\n\Output format:\n\{{\"entities\":[{{\"local_id\":\"e1\",\"name\":\"entity name\",\"type\":\"type key\",\"specific_type\":\"what you would call it\"}}],\n\- \"facts\":[{{\"subject\":\"subject entity name\",\"subject_ref\":\"e1\",\"predicate\":\"relation key\",\"object\":\"object entity name\",\"object_ref\":\"e2\",\n\+ \"facts\":[{{\"subject\":\"subject entity name\",\"subject_ref\":\"e1\",\"subject_span\":\"the words in quote that name the subject\",\"predicate\":\"relation key\",\"object\":\"object entity name\",\"object_ref\":\"e2\",\"object_span\":\"the words in quote that name the object\",\n\\"valid_from\":\"2023-01\",\"valid_to\":null,\"confidence\":0.9,\"quote\":\"verbatim supporting quote\"}}]}}\n\\n\Rules:\n\@@ -302,15 +309,10 @@ pub fn build_messages(including A, B, C and D\" is four facts, not one; \"advisors A and B\" is two. \Do not collapse an enumeration into a summary or into its first member. \The same applies to the entities: each named party is its own entity.\n\- 8d. A subject is the thing the sentence is about, not a name inside it. A group \- described by its relation to an entity — \"former X employees\", \"companies \- using X\", \"X's investors\", \"X personnel\" — is not X: never write X as the \- subject of what the group did. State it from the named participant with the \- description as a \"value\": {{\"subject\":\"Anthropic\",\"subject_ref\":\"e2\",\- \"predicate\":\"founded_by\",\"value\":\"former OpenAI personnel\",\- \"confidence\":0.9,\"quote\":\"...\"}}. When no participant is named, leave the \- sentence out: an edge between two named entities that the text never states is \- worse than a missing one.\n\+ 8d. subject_span and object_span are the exact words in quote that name each side. \+ Copy them; never paraphrase. When the words that do the thing are a description \+ rather than a name — \"former X employees\", \"companies using X\" — the span \+ is that description, whatever you wrote in subject.\n\9. The same holds for entity types: if none of the listed types fits, write the type \the text implies, in snake_case (e.g. \"model\", \"technology\"). Do not fall back \to a broad listed type such as \"thing\" or \"creative_work\" merely because \@@ -1262,6 +1264,26 @@ mod tests {assert!(parse_response(r#"{"facts": [{"subject": "a"#).is_err());}+ /// 片段字段可有可无:老模型输出没有它们,照常解析+ #[test]+ fn spans_parse_and_default_to_none() {+ let with = parse_response(+ r#"{"entities":[],"facts":[{"subject":"OpenAI","predicate":"founded","object":"Anthropic","subject_span":"Former OpenAI personnel","object_span":"Anthropic"}]}"#,+ )+ .unwrap();+ assert_eq!(+ with.facts[0].subject_span.as_deref(),+ Some("Former OpenAI personnel")+ );+ assert_eq!(with.facts[0].object_span.as_deref(), Some("Anthropic"));+ let without = parse_response(+ r#"{"entities":[],"facts":[{"subject":"OpenAI","predicate":"founded","object":"Anthropic"}]}"#,+ )+ .unwrap();+ assert!(without.facts[0].subject_span.is_none());+ assert!(without.facts[0].object_span.is_none());+ }+#[test]fn parse_response_with_fence() {let raw = "好的,结果如下:\n```json\n{\"entities\":[{\"name\":\"张三\",\"type\":\"person\"}],\"facts\":[]}\n```";@@ -1330,7 +1352,7 @@ mod tests {assert!(system.contains("\"local_id\":\"e1\""));assert!(system.contains("\"subject_ref\":\"e1\""));// #578:跟 X 有关的一群人不是 X- assert!(system.contains("is not X: never write X as the"));+ assert!(system.contains("subject_span and object_span are the exact words"));assert!(system.contains("unique within this response"));assert!(system.contains("Reuse the same local_id"));assert!(system.contains("permanent identity is proven"));diff --git a/crates/utopia-server/src/extraction.rs b/crates/utopia-server/src/extraction.rsindex b5d9c9d0..4ec9453d 100644--- a/crates/utopia-server/src/extraction.rs+++ b/crates/utopia-server/src/extraction.rs@@ -133,133 +133,236 @@ fn reads_like_a_sentence(words: &[String], raw_last: Option<&str>) -> bool {/// 守卫的样本全部来自一份语料,换一份就漏——换规则之前先要一份**跨语料的标注集**。/// 命中只记 `clause_suspect`(例句进 `extraction_drops`),实体照常落库;攒够两份语料的/// 样本再决定哪条升成硬规则。返回的是信号名,作为记录的 detail-/// 主语在自己的引文里**只**当修饰语出现时,回它所在的那个短语(#578)。+/// 槽位片段核对的结论(#582)+#[derive(Debug, PartialEq)]+enum SpanVerdict {+ /// 没给片段,或片段就是所绑的那个名字(同名、同词干、名字的一部分、名字后面接着+ /// 大写的续词——"Anthropic PBC")+ Ok,+ /// 片段不在引文里:模型没照抄。当没给处理,记一笔+ NotInQuote,+ /// 片段点的是另一个声明过的实体:改绑到它+ Rebind(String),+ /// 片段是围着某个名字的短语,那个名字在里面只是修饰语(后面还有词、或带所有格):+ /// 描述,不是实体+ Described(String),+ /// 片段是所绑名字前面带了别的词:头衔("entrepreneur Tasha McCauley")还是另一件+ /// 东西("companies using OpenAI"),机器分不开。绑定照旧,只记+ Prefixed(String),+ /// 片段里没有任何声明过的名字:模型消解了指代("him"、"the company")。绑定照旧,只记+ Coreference(String),+ /// 片段抄的是事实另一侧的名字(宾语片段写成了主语):抄错了位置。绑定照旧,只记+ Misplaced(String),+}++/// 片段在不在引文里:大小写、空白都不论+fn span_in_quote(span: &str, quote: &str) -> bool {+ let norm = |s: &str| {+ s.split_whitespace()+ .collect::<Vec<_>>()+ .join(" ")+ .to_lowercase()+ };+ let (s, q) = (norm(span), norm(quote));+ !s.is_empty() && q.contains(&s)+}++/// 一个词:去掉两头标点和所有格后的小写形态,连同原样(看大小写用)+#[derive(Debug, Clone)]+struct Word<'a> {+ clean: String,+ raw: &'a str,+}++/// 片段拆成词:去两头标点、去所有格("OpenAI's" → openai)、去开头的冠词+fn span_words(s: &str) -> Vec<Word<'_>> {+ let mut words: Vec<Word<'_>> = s+ .split_whitespace()+ .filter_map(|raw| {+ let w = raw.trim_matches(|c: char| !c.is_alphanumeric());+ let w = w+ .strip_suffix("'s")+ .or_else(|| w.strip_suffix("\u{2019}s"))+ .unwrap_or(w);+ (!w.is_empty()).then(|| Word {+ clean: w.to_lowercase(),+ raw,+ })+ })+ .collect();+ while words+ .first()+ .is_some_and(|w| matches!(w.clean.as_str(), "the" | "a" | "an"))+ {+ words.remove(0);+ }+ words+}++/// 一个词是不是专名的样子:首字符大写或数字("PBC"、"LLC"、"LX"、"Global")+fn looks_proper(raw: &str) -> bool {+ raw.chars()+ .find(|c| c.is_alphanumeric())+ .is_some_and(|c| c.is_uppercase() || c.is_numeric())+}++/// 词序列 needle 在 hay 里连续出现的位置+fn find_words(hay: &[Word<'_>], needle: &[Word<'_>]) -> Option<usize> {+ if needle.is_empty() || needle.len() > hay.len() {+ return None;+ }+ (0..=hay.len() - needle.len()).find(|&i| {+ needle+ .iter()+ .zip(&hay[i..])+ .all(|(n, h)| n.clean == h.clean)+ })+}++/// 片段说的是不是这个名字:同名、同词干(Acme / Acme Corp.)、泛用后缀互推——+/// 与消解召回同一套判据(`recall_keys`);或者片段的词全在名字里("Altman" 之于+/// "Sam Altman","Anthropic" 之于 "Anthropic, PBC")+fn slot_matches(span: &str, name: &str) -> bool {+ let keys = |s: &str| {+ let clean = span_words(s)+ .into_iter()+ .map(|w| w.clean)+ .collect::<Vec<_>>()+ .join(" ");+ utopia_store::resolution::recall_keys(&utopia_store::resolution::normalize_name(&clean))+ };+ let (a, b) = (keys(span), keys(name));+ if !a.is_empty() && a.iter().any(|k| b.contains(k)) {+ return true;+ }+ let (s, n) = (span_words(span), span_words(name));+ !s.is_empty() && s.iter().all(|w| n.iter().any(|x| x.clean == w.clean))+}++/// **模型抄,机器判**(#582)。///-/// "Former OpenAI personnel have founded … Anthropic" 抽成 `OpenAI —founded→ Anthropic`,-/// "Over one hundred companies using OpenAI contacted Anthropic" 抽成 `OpenAI —contacted→-/// Anthropic`——两条都排在两家公司之间路径的第一位。句子的主语是「跟 OpenAI 有关的一群人」,-/// 模型伸手拿了句子里唯一有名字的东西。+/// #559、#578、#581 是同一件事的三张脸:模型把事实挂到了错的参与者身上——+/// "former OpenAI personnel" 写成 OpenAI,"lawsuit against OpenAI" 造成节点。给每一种+/// 形状写一条规则、配一张词表,量出来规则的服从率一半上下,词表只认见过的形状。+/// 这里换一个问法:不问模型「这算不算实体」,让它把引文里点名每一侧的那几个字+/// 抄出来(`subject_span` / `object_span`)。抄是模型稳定会做的事;判断交给机器:///-/// 三种形状,都要求主语的每一次出现都在其中;只要有一次它是正常的主语-/// ("OpenAI announced … ; former OpenAI staff …"),就不算缩写:-/// - 后面跟一个群体名词:`OpenAI personnel`、`OpenAI's investors`、`former OpenAI employees`-/// - 前面是群体名词加介词:`companies using OpenAI`、`employees of OpenAI`+/// 1. 片段是所绑的名字(同名、同词干、名字的一部分)→ 放行;+/// 2. 片段是另一个声明过的实体的名字(或那名字的一部分)→ 改绑;+/// 3. 片段里含所绑的名字、名字**后面**还有词("former OpenAI personnel"、"The Verge+/// reporter")或名字带所有格("Anthropic's safeguards")→ 名字在里面只是修饰语,+/// 这是描述。后面的词全是专名的样子("Anthropic PBC"、"OpenAI Global LLC")不算;+/// 4. 名字只在片段**末尾**、前面带了词 → 头衔还是另一件东西分不开,绑定照旧、只记;+/// 5. 片段里是别的声明过的名字带着修饰 → 描述;一个名字都没有 → 指代,绑定照旧、只记。///-/// 群体名词是一张短表,只收复数的集体称呼(personnel、employees、investors…)和 board;-/// 单数职位("OpenAI CEO Sam Altman announced")不收——那句以 OpenAI 为主语多半没错,-/// 而这一关拦下的事实是丢掉的,宁可漏判-fn shortened_subject(subject: &str, quote: &str) -> Option<String> {- // "partners" 与 "teams" 不收:多半是动词("OpenAI partners with Microsoft"、"teams up with"),- // 实测一跑就拦掉了 6 条真的合作关系- const GROUP: [&str; 28] = [- "personnel",- "employees",- "employee",- "staff",- "staffers",- "researchers",- "scientists",- "engineers",- "executives",- "alumni",- "investors",- "customers",- "users",- "members",- "founders",- "leadership",- "team",- "people",- "workers",- "developers",- "veterans",- "insiders",- "backers",- "shareholders",- "clients",- "affiliates",- "companies",- "board",- ];- const LINK: [&str; 7] = ["using", "of", "from", "at", "inside", "within", "by"];- const BEFORE: [&str; 5] = ["former", "ex", "then", "current", "fellow"];- let subject = subject.trim();- if subject.is_empty() || quote.is_empty() {- return None;+/// 按语法位置来的补充:名字后面紧跟逗号是同位语("Helen Toner, strategy director+/// for …"),还是它;片段以这条事实**另一侧**的名字结尾(宾语片段抄成了主语),是抄错+/// 位置,只记。+///+/// 同一套判据还用在模型**写的名字**和它 **ref 指的实体**之间(`written_verdict`):写+/// "OpenAI employees" 却 ref 到 OpenAI,是它自己的两个答案打架,v5 那轮的最后一条假边+/// ("Eleven employees left OpenAI … to establish Anthropic" → Anthropic founded_by OpenAI)+/// 就是这么来的——片段 "eleven employees" 里没有名字,只看片段拦不住。+///+/// 只有 3 和 5 前半改动事实(主语丢、宾语落字面值);其余都是信号,让每一层的比率+/// 按库、按模型读得出来+fn verify_span(+ span: Option<&str>,+ name: &str,+ other: &str,+ quote: &str,+ declared: &HashMap<String, Uuid>,+) -> SpanVerdict {+ let Some(span) = span.map(str::trim).filter(|s| !s.is_empty()) else {+ return SpanVerdict::Ok;+ };+ if !span_in_quote(span, quote) {+ return SpanVerdict::NotInQuote;}- let q = quote.to_lowercase();- let s = subject.to_lowercase();- let bytes = q.as_bytes();- let is_word = |b: u8| b.is_ascii_alphanumeric() || b == b'-';- // 引文里从 `end` 往后的下一个词(跳过空白和 's)- let word_after = |mut end: usize| -> Option<(usize, usize)> {- if q[end..].starts_with("'s") || q[end..].starts_with("\u{2019}s") {- end += q[end..].chars().next().map(char::len_utf8).unwrap_or(1) + 1;- }- while end < bytes.len() && bytes[end] == b' ' {- end += 1;- }- let start = end;- while end < bytes.len() && is_word(bytes[end]) {- end += 1;+ if slot_matches(span, name) {+ return SpanVerdict::Ok;+ }+ let s = span_words(span);+ let n = span_words(name);+ if s.is_empty() {+ return SpanVerdict::Coreference(span.to_string());+ }++ // 2. 另一个声明过的实体:精确/词干命中优先,其次名字包住片段的(取最短的那个)+ let mut others: Vec<&String> = declared.keys().filter(|k| k.as_str() != name).collect();+ others.sort();+ if let Some(k) = others.iter().find(|k| {+ let keys = |x: &str| {+ let clean = span_words(x)+ .into_iter()+ .map(|w| w.clean)+ .collect::<Vec<_>>()+ .join(" ");+ utopia_store::resolution::recall_keys(&utopia_store::resolution::normalize_name(&clean))+ };+ let (a, b) = (keys(span), keys(k));+ a.iter().any(|x| b.contains(x))+ }) {+ return SpanVerdict::Rebind((*k).clone());+ }+ // 单个普通词("company")包在别的名字里不算:那是指代,不是点名+ let names_something = s.len() >= 2 || looks_proper(s[0].raw);+ let mut supersets: Vec<(&String, usize)> = others+ .iter()+ .filter_map(|k| {+ let kw = span_words(k);+ (names_something && s.iter().all(|w| kw.iter().any(|x| x.clean == w.clean)))+ .then_some((*k, kw.len()))+ })+ .collect();+ supersets.sort_by_key(|(_, len)| *len);+ if let Some((k, _)) = supersets.first() {+ return SpanVerdict::Rebind((*k).clone());+ }+ // 所绑的名字在片段里的位置;名字后面紧跟逗号是同位语("TBPN, a media company in+ // California"),还是它——先于下面所有判断+ let found = find_words(&s, &n);+ if let Some(i) = found {+ let end = i + n.len();+ if end < s.len() && s[end - 1].raw.trim_end().ends_with(',') {+ return SpanVerdict::Ok;}- (end > start).then_some((start, end))+ }++ // 片段以事实另一侧的名字结尾:抄错了位置(宾语片段写成了主语),不是绑错了实体。+ // 「片段以别的声明名结尾就改绑到它」试过两轮(v4/v5):介词的补语、名单的最后一项、+ // 并列的后一个("Swisher and … Alex Heath")都会被当成头,错的多过对的,不做+ let ends_with = |k: &str| {+ let kw = span_words(k);+ !kw.is_empty() && kw.len() < s.len() && find_words(&s[s.len() - kw.len()..], &kw) == Some(0)};- // 引文里到 `at` 为止的前一个词- let word_before = |mut at: usize| -> Option<(usize, usize)> {- while at > 0 && bytes[at - 1] == b' ' {- at -= 1;- }- let end = at;- while at > 0 && is_word(bytes[at - 1]) {- at -= 1;+ if !other.is_empty() && !slot_matches(name, other) && ends_with(other) {+ return SpanVerdict::Misplaced(span.to_string());+ }++ // 3 / 4. 所绑的名字在片段里+ if let Some(i) = found {+ let end = i + n.len();+ let last = s[end - 1].raw;+ let possessive = last.ends_with("'s") || last.ends_with("\u{2019}s");+ let after = &s[end..];+ if possessive || after.iter().any(|w| !looks_proper(w.raw)) {+ return SpanVerdict::Described(span.to_string());}- (end > at).then_some((at, end))- };- let mut seen = false;- let mut phrase: Option<(usize, usize)> = None;- let mut from = 0;- while let Some(pos) = q[from..].find(&s) {- let at = from + pos;- let end = at + s.len();- from = end;- let boundary =- (at == 0 || !is_word(bytes[at - 1])) && (end >= bytes.len() || !is_word(bytes[end]));- if !boundary {- continue;- }- seen = true;- let after = word_after(end);- let before = word_before(at);- let span = if after.is_some_and(|(a, b)| GROUP.contains(&&q[a..b])) {- // `OpenAI personnel` / `OpenAI's investors`,前面若有 former 一并带上- let start = match before {- Some((a, b)) if BEFORE.contains(&&q[a..b]) => a,- _ => at,- };- Some((start, after.map(|(_, b)| b).unwrap_or(end)))- } else if let Some((la, lb)) = before.filter(|(a, b)| LINK.contains(&&q[*a..*b])) {- // `companies using OpenAI` / `employees of OpenAI`- match word_before(la).filter(|(a, b)| GROUP.contains(&&q[*a..*b])) {- Some((ga, _)) => Some((ga, end)),- None => {- let _ = lb;- None- }- }- } else {- None- };- // 有一次是正常主语,就不是缩写- let sp = span?;- if phrase.is_none() {- phrase = Some(sp);+ if after.is_empty() && i > 0 {+ return SpanVerdict::Prefixed(span.to_string());}+ return SpanVerdict::Ok;}- if !seen {- return None;++ // 5. 别的名字带着修饰,或一个名字都没有+ if others.iter().any(|k| {+ let kw = span_words(k);+ find_words(&s, &kw).is_some()+ }) {+ return SpanVerdict::Described(span.to_string());}- phrase.map(|(a, b)| quote[a..b].to_string())+ SpanVerdict::Coreference(span.to_string())}fn clause_suspect(name: &str) -> Option<&'static str> {@@ -543,6 +646,38 @@ struct BoundEntity {type_id: Option<Uuid>,}+/// 模型写的名字和它 ref 指的实体对不对得上(#582)。没有 ref、或写的就是那个名字时+/// 无事;否则把写的名字当片段核对,写的名字自己当引文(免掉在不在引文那一关)。+/// 只有描述和改绑两种结论会用到,其余当无事+fn written_verdict(+ written: &str,+ bound: &str,+ other: &str,+ referenced: bool,+ declared: &HashMap<String, Uuid>,+) -> SpanVerdict {+ if !referenced || slot_matches(written, bound) {+ return SpanVerdict::Ok;+ }+ match verify_span(Some(written), bound, other, written, declared) {+ v @ (SpanVerdict::Described(_) | SpanVerdict::Rebind(_)) => v,+ _ => SpanVerdict::Ok,+ }+}++/// 一侧绑上的名字:有 ref 就是 ref 指的那个实体声明的名字,没有就是模型写的(#582)+fn bound_name<'a>(+ ref_names: &'a HashMap<String, String>,+ reference: Option<&str>,+ written: &'a str,+) -> &'a str {+ reference+ .map(str::trim)+ .and_then(|h| ref_names.get(h))+ .map(String::as_str)+ .unwrap_or(written)+}+fn referenced_entity(ref_entities: &HashMap<String, BoundEntity>,reference: &str,@@ -921,6 +1056,8 @@ async fn run(state: &AppState, document_id: Uuid, proposer: Proposer) -> anyhow:continue;}};+ // 模型的原话只在 debug 级别看得到:查它对哪几个字段怎么填(#582 的片段)时开+ tracing::debug!(%document_id, seq = chunk.seq, reply = %reply, "抽取原始回复");let extraction = match utopia_extract::parse_response(&reply) {Ok(x) => x,Err(e) => {@@ -982,6 +1119,14 @@ async fn run(state: &AppState, document_id: Uuid, proposer: Proposer) -> anyhow:)}).collect();+ // 句柄 → 声明的名字:片段核对要对着**绑上的**那个名字看(#582)。模型写+ // "OpenAI personnel" 却 ref 到 e1=OpenAI 时,错在 ref 上,片段对着 "OpenAI"+ // 才看得出来+ let mut ref_names: HashMap<String, String> = doc_entities+ .iter()+ .enumerate()+ .map(|(index, (_, _, name))| (format!("k{}", index + 1), name.clone()))+ .collect();let mut response_claims: HashMap<String, Vec<Uuid>> = HashMap::new();// Resolve handled definitions first. This matters for a mixed response: a later@@ -1076,6 +1221,7 @@ async fn run(state: &AppState, document_id: Uuid, proposer: Proposer) -> anyhow:).await?;ref_entities.insert(handle.to_string(), BoundEntity { id, type_id });+ ref_names.insert(handle.to_string(), name.to_string());id} else {resolve_bare(@@ -1128,6 +1274,14 @@ async fn run(state: &AppState, document_id: Uuid, proposer: Proposer) -> anyhow:entity_type_of.insert(name.to_string(), type_id);}+ // 改绑的候选:这次回复声明的实体,加上提示词里给过的库内实体(#582)+ let span_declared: HashMap<String, Uuid> = {+ let mut m = entity_ids.clone();+ for (id, _, name) in &doc_entities {+ m.entry(name.clone()).or_insert(*id);+ }+ m+ };for f in &extraction.facts {let confidence = f.confidence.unwrap_or(0.7).clamp(0.0, 1.0);if confidence < MIN_CONFIDENCE {@@ -1589,30 +1743,155 @@ async fn run(state: &AppState, document_id: Uuid, proposer: Proposer) -> anyhow:}}- // **主语是跟 X 有关的一群人,写成了 X**(#578):不落,记账。改写成- // 「Anthropic —founded_by→ "former OpenAI personnel"」是提示词那条规则的活,- // 这里只量它还错多少——两条都在路径第一位,一条假边比一条漏边贵- if let Some(phrase) =- shortened_subject(f.subject.trim(), f.quote.as_deref().unwrap_or(""))- {+ // **槽位片段核对**(#582,取代 #578 的词表):模型交出引文里点名每一侧的那几个+ // 字,机器核对(`verify_span`)。描述做主语不落、做宾语落成字面值;点了别的+ // 实体就改绑;其余都只记不拦+ let quote_text = f.quote.as_deref().unwrap_or("");+ // 对着绑上的名字看:有 ref 就是 ref 指的那个实体的名字,没有就是模型写的名字+ let bound_subject = bound_name(&ref_names, f.subject_ref.as_deref(), f.subject.trim());+ let bound_object = bound_name(&ref_names, f.object_ref.as_deref(), object_name);+ // 片段说了算;片段没说清(放行、不在引文、前缀、指代)时,再看模型写的名字+ // 跟它 ref 指的实体对不对得上+ let decisive = |v: &SpanVerdict| {+ matches!(+ v,+ SpanVerdict::Described(_) | SpanVerdict::Rebind(_) | SpanVerdict::Misplaced(_)+ )+ };+ let mut subject_verdict = verify_span(+ f.subject_span.as_deref(),+ bound_subject,+ bound_object,+ quote_text,+ &span_declared,+ );+ if !decisive(&subject_verdict) {+ let w = written_verdict(+ f.subject.trim(),+ bound_subject,+ bound_object,+ f.subject_ref.is_some(),+ &span_declared,+ );+ if decisive(&w) {+ subject_verdict = w;+ }+ }+ let mut object_verdict = verify_span(+ f.object_span.as_deref(),+ bound_object,+ bound_subject,+ quote_text,+ &span_declared,+ );+ if !decisive(&object_verdict) {+ let w = written_verdict(+ object_name,+ bound_object,+ bound_subject,+ f.object_ref.is_some(),+ &span_declared,+ );+ if decisive(&w) {+ object_verdict = w;+ }+ }+ let mut rebound_subject: Option<String> = None;+ let mut rebound_object: Option<String> = None;+ let mut object_described: Option<String> = None;+ let mut subject_described = false;+ for (side, verdict, span, bound) in [+ (+ "subject",+ &subject_verdict,+ f.subject_span.as_deref(),+ bound_subject,+ ),+ (+ "object",+ &object_verdict,+ f.object_span.as_deref(),+ bound_object,+ ),+ ] {+ let (reason, example) = match verdict {+ SpanVerdict::Ok => continue,+ SpanVerdict::NotInQuote => (+ utopia_store::extraction_drops::reason::SPAN_NOT_IN_QUOTE,+ format!("{} ({bound})", span.unwrap_or("")),+ ),+ SpanVerdict::Rebind(name) => {+ if side == "subject" {+ rebound_subject = Some(name.clone());+ } else {+ rebound_object = Some(name.clone());+ }+ (+ utopia_store::extraction_drops::reason::SPAN_REBOUND,+ format!("{} → {name} (was {bound})", span.unwrap_or("")),+ )+ }+ SpanVerdict::Described(text) => {+ if side == "subject" {+ subject_described = true;+ (+ utopia_store::extraction_drops::reason::SUBJECT_DESCRIBED,+ format!("{text} ({bound})"),+ )+ } else {+ object_described = Some(text.clone());+ (+ utopia_store::extraction_drops::reason::OBJECT_DESCRIBED,+ format!("{text} ({bound})"),+ )+ }+ }+ SpanVerdict::Prefixed(text) => (+ utopia_store::extraction_drops::reason::SPAN_PREFIXED,+ format!("{text} ({bound})"),+ ),+ SpanVerdict::Coreference(text) => (+ utopia_store::extraction_drops::reason::SPAN_COREFERENCE,+ format!("{text} ({bound})"),+ ),+ SpanVerdict::Misplaced(text) => (+ utopia_store::extraction_drops::reason::SPAN_MISPLACED,+ format!("{text} ({bound})"),+ ),+ };drop_signal(state,doc.kb_id,document_id,- utopia_store::extraction_drops::reason::SUBJECT_SHORTENED,+ reason,&f.predicate,- Some(&phrase),+ Some(&example),).await;+ }+ if subject_described {continue;}+ let subject_name: &str = rebound_subject.as_deref().unwrap_or(f.subject.trim());+ let subject_ref_eff: Option<&str> = if rebound_subject.is_some() {+ None+ } else {+ f.subject_ref.as_deref().map(str::trim)+ };+ let object_name: &str = rebound_object.as_deref().unwrap_or(object_name);+ let object_ref_eff: Option<&str> =+ if rebound_object.is_some() || object_described.is_some() {+ None+ } else {+ f.object_ref.as_deref().map(str::trim)+ };// 主宾没在 entities 里声明时(模型偶尔漏报):库里已经有这个名字的就用它,// 库里也没有的**不建**(#559)。从前这里一律先建出来、类型留空,结果// 一个库里 20% 的实体是 "lawsuit against OpenAI"、"$5 billion"、"March 2024"// 这样的描述——几乎全部只当过宾语,从没当过主语。漏报的实体多半在// 前面的分块或别的文档里已经声明过,按名字找得到;找不到的就是描述。// 描述做主语的事实丢掉并记账,做宾语的事实照落,宾语落成字面值- let subject_id = match f.subject_ref.as_deref().map(str::trim) {+ let subject_id = match subject_ref_eff {Some(handle) => match referenced_entity(&ref_entities, handle) {Some(bound) => bound.id,None => {@@ -1629,13 +1908,12 @@ async fn run(state: &AppState, document_id: Uuid, proposer: Proposer) -> anyhow:}},None => {- let binding =- no_ref_name_binding(&entity_ids, &handled_by_name, f.subject.trim());+ let binding = no_ref_name_binding(&entity_ids, &handled_by_name, subject_name);if matches!(binding, NoRefNameBinding::Missing)&& utopia_store::resolution::existing_by_name(&state.pool,doc.kb_id,- f.subject.trim(),+ subject_name,).await?.is_none()@@ -1646,7 +1924,7 @@ async fn run(state: &AppState, document_id: Uuid, proposer: Proposer) -> anyhow:document_id,utopia_store::extraction_drops::reason::SUBJECT_NOT_DECLARED,&f.predicate,- Some(f.subject.trim()),+ Some(subject_name),).await;continue;@@ -1655,14 +1933,14 @@ async fn run(state: &AppState, document_id: Uuid, proposer: Proposer) -> anyhow:NoRefNameBinding::Legacy(id) => id,NoRefNameBinding::AmbiguousHandled | NoRefNameBinding::Missing => {touched_names.insert(- utopia_store::resolution::normalize_name(f.subject.trim())+ utopia_store::resolution::normalize_name(subject_name).to_lowercase(),);resolve_bare(&state.pool,doc.kb_id,None,- f.subject.trim(),+ subject_name,ctx,Some(&chunk.text),&mut doc_cache,@@ -1676,7 +1954,7 @@ async fn run(state: &AppState, document_id: Uuid, proposer: Proposer) -> anyhow:}}};- let object_id = match f.object_ref.as_deref().map(str::trim) {+ let object_id = match object_ref_eff {Some(handle) => match referenced_entity(&ref_entities, handle) {Some(bound) => bound.id,None => {@@ -1694,16 +1972,17 @@ async fn run(state: &AppState, document_id: Uuid, proposer: Proposer) -> anyhow:},None => {let binding = no_ref_name_binding(&entity_ids, &handled_by_name, object_name);- if matches!(binding, NoRefNameBinding::Missing)- && utopia_store::resolution::existing_by_name(- &state.pool,- doc.kb_id,- object_name,- )- .await?- .is_none()+ if object_described.is_some()+ || (matches!(binding, NoRefNameBinding::Missing)+ && utopia_store::resolution::existing_by_name(+ &state.pool,+ doc.kb_id,+ object_name,+ )+ .await?+ .is_none()){- // 没声明、库里也没有:宾语落成字面值。谓词照旧对本体;+ // 没声明、库里也没有,或者片段说它是个描述:宾语落成字面值。谓词照旧对本体;// 被动形(`_by`)本该主宾对调,而字面值当不了主语,那条就不给谓词,// 原词留在证据上let predicate_id = match pred_index.lookup(f.predicate.as_str()) {@@ -1721,16 +2000,20 @@ async fn run(state: &AppState, document_id: Uuid, proposer: Proposer) -> anyhow:None}};- drop_signal(- state,- doc.kb_id,- document_id,- utopia_store::extraction_drops::reason::OBJECT_UNDECLARED,- &f.predicate,- Some(object_name),- )- .await;- let literal = serde_json::json!({ "value": object_name });+ let literal_text: &str = object_described.as_deref().unwrap_or(object_name);+ // 描述那一路在上面核对时已经记过账;这里只记「没声明」的+ if object_described.is_none() {+ drop_signal(+ state,+ doc.kb_id,+ document_id,+ utopia_store::extraction_drops::reason::OBJECT_UNDECLARED,+ &f.predicate,+ Some(object_name),+ )+ .await;+ }+ let literal = serde_json::json!({ "value": literal_text });if await_nod {if let utopia_store::pending::Outcome::Proposed(_) =utopia_store::pending::propose(@@ -2532,52 +2815,347 @@ mod name_tests {#[cfg(test)]mod tests {- use super::shortened_subject;+ use super::{slot_matches, span_in_quote, verify_span, SpanVerdict};+ fn declared(names: &[&str]) -> HashMap<String, Uuid> {+ names+ .iter()+ .map(|n| (n.to_string(), Uuid::now_v7()))+ .collect()+ }- /// 主语在引文里只当修饰语出现:两句真实的错例,和几句不该拦的+ /// 片段核对:#578 的两句真实错例;改绑;头衔与指代只记;正常的放行#[test]- fn a_group_described_by_its_relation_to_x_is_not_x() {+ fn a_span_that_names_a_description_is_not_the_entity() {+ let d = declared(&[+ "OpenAI",+ "Anthropic",+ "Sam Altman",+ "OpenAI's board of directors",+ "The Verge",+ "Tasha McCauley",+ ]);+ let quote = "Former OpenAI personnel have founded competing AI companies Anthropic, SpaceXAI, Safe Superintelligence Inc., and Thinking Machines Lab";+ // 名字后面还有词:名字只是修饰语+ assert_eq!(+ verify_span(Some("Former OpenAI personnel"), "OpenAI", "", quote, &d),+ SpanVerdict::Described("Former OpenAI personnel".into())+ );+ assert_eq!(+ verify_span(Some("Anthropic"), "Anthropic", "", quote, &d),+ SpanVerdict::Ok+ );+ // 所有格:名字只是修饰语+ let q3 = "Claude bypassed Anthropic's safeguards";+ assert_eq!(+ verify_span(Some("Anthropic's safeguards"), "Anthropic", "", q3, &d),+ SpanVerdict::Described("Anthropic's safeguards".into())+ );+ // 另一个名字带着修饰,绑到了第三方+ assert_eq!(+ verify_span(+ Some("The Verge reporter"),+ "Sam Altman",+ "",+ "a The Verge reporter wrote",+ &d+ ),+ SpanVerdict::Described("The Verge reporter".into())+ );+ // 名字前面带了词:头衔还是另一件东西分不开,只记+ let q2 = "Over one hundred companies using OpenAI contacted Anthropic";+ assert_eq!(+ verify_span(Some("companies using OpenAI"), "OpenAI", "", q2, &d),+ SpanVerdict::Prefixed("companies using OpenAI".into())+ );+ assert_eq!(+ verify_span(+ Some("entrepreneur Tasha McCauley"),+ "Tasha McCauley",+ "",+ "with entrepreneur Tasha McCauley on the board",+ &d+ ),+ SpanVerdict::Prefixed("entrepreneur Tasha McCauley".into())+ );+ // 片段点了另一个声明过的实体:改绑,不丢assert_eq!(- shortened_subject(+ verify_span(+ Some("Sam Altman"),"OpenAI",- "Former OpenAI personnel have founded competing AI companies Anthropic, SpaceXAI, Safe Superintelligence Inc., and Thinking Machines Lab"- )- .as_deref(),- Some("Former OpenAI personnel")+ "",+ "Sam Altman announced the deal",+ &d+ ),+ SpanVerdict::Rebind("Sam Altman".into())+ );+ assert_eq!(+ verify_span(+ Some("Altman"),+ "OpenAI",+ "",+ "Altman announced the deal",+ &d+ ),+ SpanVerdict::Rebind("Sam Altman".into()));assert_eq!(- shortened_subject(+ verify_span(+ Some("OpenAI's board"),"OpenAI",- "Over one hundred companies using OpenAI contacted Anthropic, according to The Information"+ "",+ "OpenAI's board removed Sam Altman as CEO",+ &d+ ),+ SpanVerdict::Rebind("OpenAI's board of directors".into())+ );+ // 指代:没有任何名字,绑定照旧、只记+ assert_eq!(+ verify_span(+ Some("him"),+ "Sam Altman",+ "",+ "the board reinstated him",+ &d+ ),+ SpanVerdict::Coreference("him".into())+ );+ // 单个普通词包在别的名字里也是指代,不改绑("the company" ≠ "for-profit company")+ let d2 = declared(&[+ "OpenAI",+ "for-profit company",+ "Satya Nadella",+ "Jony Ive",+ "Apple",+ "Microsoft",+ "Helen Toner",+ "Fidji Simo",+ ]);+ assert_eq!(+ verify_span(+ Some("the company"),+ "OpenAI",+ "",+ "the company took over",+ &d2+ ),+ SpanVerdict::Coreference("the company".into())+ );+ // 片段以另一个名字结尾:不猜它是头(v4/v5 里猜错的多过猜对的),照描述处理+ assert_eq!(+ verify_span(+ Some("Microsoft chief executive Satya Nadella"),+ "Microsoft",+ "OpenAI",+ "convinced Microsoft chief executive Satya Nadella",+ &d2+ ),+ SpanVerdict::Described("Microsoft chief executive Satya Nadella".into())+ );+ assert_eq!(+ verify_span(+ Some("Swisher and The Verge reporter Alex Heath"),+ "Kara Swisher",+ "",+ "Swisher and The Verge reporter Alex Heath stated",+ &declared(&["Kara Swisher", "Alex Heath", "The Verge"])+ ),+ SpanVerdict::Described("Swisher and The Verge reporter Alex Heath".into())+ );+ // 以另一侧的名字结尾:抄错了位置,绑定照旧、只记+ assert_eq!(+ verify_span(+ Some("CEO of Applications: Fidji Simo"),+ "OpenAI",+ "Fidji Simo",+ "CEO of Applications: Fidji Simo",+ &d2+ ),+ SpanVerdict::Misplaced("CEO of Applications: Fidji Simo".into())+ );+ // 末尾的名字是介词的补语或名单的最后一项,不是头:不改绑(v4 的四个错例)+ let d3 = declared(&[+ "OpenAI",+ "companies using OpenAI",+ "TBPN",+ "California",+ "Pioneer Building",+ "San Francisco",+ "Anthropic",+ ]);+ assert_eq!(+ verify_span(+ Some("Over one hundred companies using OpenAI"),+ "companies using OpenAI",+ "Anthropic",+ "Over one hundred companies using OpenAI contacted Anthropic",+ &d3+ ),+ SpanVerdict::Prefixed("Over one hundred companies using OpenAI".into())+ );+ assert_eq!(+ verify_span(+ Some("his vested equity in OpenAI"),+ "vested equity",+ "Sam Altman",+ "forfeited his vested equity in OpenAI",+ &d3+ ),+ SpanVerdict::Described("his vested equity in OpenAI".into())+ );+ assert_eq!(+ verify_span(+ Some("TBPN, a media company in California"),+ "TBPN",+ "OpenAI",+ "acquired TBPN, a media company in California",+ &d3+ ),+ SpanVerdict::Ok+ );+ assert_eq!(+ verify_span(+ Some("the Pioneer Building in the Mission District, San Francisco"),+ "Pioneer Building",+ "OpenAI",+ "located in the Pioneer Building in the Mission District, San Francisco",+ &d3+ ),+ SpanVerdict::Described(+ "the Pioneer Building in the Mission District, San Francisco".into())- .as_deref(),- Some("companies using OpenAI"));+ // 名字后面紧跟逗号:同位语,还是它assert_eq!(- shortened_subject("OpenAI", "OpenAI's investors pushed for a new board").as_deref(),- Some("OpenAI's investors")+ verify_span(+ Some("Helen Toner, strategy director for the Center for Security and Emerging Technology"),+ "Helen Toner",+ "OpenAI",+ "and Helen Toner, strategy director for the Center for Security and Emerging Technology",+ &d2+ ),+ SpanVerdict::Ok);+ // 没给片段:老行为+ assert_eq!(verify_span(None, "OpenAI", "", quote, &d), SpanVerdict::Ok);+ // 片段不在引文里:只记不拦assert_eq!(- shortened_subject("OpenAI", "Employees of OpenAI signed the letter").as_deref(),- Some("Employees of OpenAI")+ verify_span(Some("OpenAI staff"), "OpenAI", "", q2, &d),+ SpanVerdict::NotInQuote);- // 正常主语不拦- assert!(shortened_subject("OpenAI", "OpenAI announced GPT-4 in March 2023").is_none());- // 同一句里既是修饰语又是主语:不拦- assert!(shortened_subject(+ }++ /// 模型写的名字和它 ref 指的实体打架:写 "OpenAI employees" 却指向 OpenAI+ #[test]+ fn a_written_name_that_describes_its_reference_is_a_description() {+ use super::written_verdict;+ let d = declared(&["OpenAI",- "Former OpenAI staff left, but OpenAI itself kept hiring"- )- .is_none());- // 动词不是群体:合作关系以公司为主语是对的- assert!(shortened_subject("OpenAI", "OpenAI partners with Microsoft on Azure").is_none());- assert!(shortened_subject("OpenAI", "OpenAI teams up with Apple").is_none());- // 单数职位不收:以公司为主语多半没错- assert!(shortened_subject("OpenAI", "OpenAI CEO Sam Altman announced the plan").is_none());- // 词边界:AI 不是 OpenAI 的一部分- assert!(shortened_subject("AI", "OpenAI personnel founded Anthropic").is_none());- // 主语不在引文里:不是这一关的事- assert!(shortened_subject("Anthropic", "OpenAI personnel founded a company").is_none());+ "Anthropic",+ "Sam Altman",+ "OpenAI's board of directors",+ ]);+ // v5 的最后一条假边:片段 "eleven employees" 没有名字拦不住,写的名字拦得住+ assert_eq!(+ written_verdict("OpenAI employees", "OpenAI", "Anthropic", true, &d),+ SpanVerdict::Described("OpenAI employees".into())+ );+ assert_eq!(+ written_verdict("Former OpenAI personnel", "OpenAI", "Anthropic", true, &d),+ SpanVerdict::Described("Former OpenAI personnel".into())+ );+ // 写的是另一个声明过的实体:改绑+ assert_eq!(+ written_verdict(+ "OpenAI's board of directors",+ "OpenAI",+ "Sam Altman",+ true,+ &d+ ),+ SpanVerdict::Rebind("OpenAI's board of directors".into())+ );+ // 写的就是那个名字(含后缀、部分)、没有 ref、或是指代:无事+ assert_eq!(+ written_verdict("OpenAI, Inc.", "OpenAI", "", true, &d),+ SpanVerdict::Ok+ );+ assert_eq!(+ written_verdict("Altman", "Sam Altman", "", true, &d),+ SpanVerdict::Ok+ );+ assert_eq!(+ written_verdict("OpenAI employees", "OpenAI", "", false, &d),+ SpanVerdict::Ok+ );+ assert_eq!(+ written_verdict("the company", "OpenAI", "", true, &d),+ SpanVerdict::Ok+ );+ }++ /// 名字后面接着专名样子的续词是同一个东西;接着小写的词就不是+ #[test]+ fn a_name_continued_in_capitals_is_the_same_thing() {+ let d = declared(&["Anthropic", "OpenAI"]);+ assert_eq!(+ verify_span(+ Some("Anthropic PBC"),+ "Anthropic",+ "",+ "Anthropic PBC filed",+ &d+ ),+ SpanVerdict::Ok+ );+ assert_eq!(+ verify_span(+ Some("OpenAI Global, LLC"),+ "OpenAI",+ "",+ "OpenAI Global, LLC is the for-profit arm",+ &d+ ),+ SpanVerdict::Ok+ );+ assert_eq!(+ verify_span(+ Some("OpenAI employees"),+ "OpenAI",+ "",+ "OpenAI employees left",+ &d+ ),+ SpanVerdict::Described("OpenAI employees".into())+ );+ }++ #[test]+ fn a_slot_matches_its_name_by_stem_and_suffix() {+ assert!(slot_matches("OpenAI", "OpenAI, Inc."));+ assert!(slot_matches("Acme", "Acme Corp."));+ assert!(slot_matches("openai", "OpenAI"));+ assert!(slot_matches("OpenAI's", "OpenAI"));+ assert!(slot_matches("Altman", "Sam Altman"));+ assert!(slot_matches("Anthropic", "Anthropic, PBC"));+ assert!(slot_matches(+ "the Center for Security and Emerging Technology",+ "Center for Security and Emerging Technology"+ ));+ assert!(!slot_matches("Former OpenAI personnel", "OpenAI"));+ assert!(!slot_matches("Anthropic", "OpenAI"));+ }++ #[test]+ fn a_span_is_found_in_its_quote_regardless_of_case_and_spacing() {+ assert!(span_in_quote(+ "former openai personnel",+ "Former OpenAI personnel have founded"+ ));+ assert!(!span_in_quote(+ "OpenAI staff",+ "Former OpenAI personnel have founded"+ ));+ assert!(!span_in_quote("", "anything"));}use super::{diff --git a/crates/utopia-store/src/extraction_drops.rs b/crates/utopia-store/src/extraction_drops.rsindex 6337a704..b265f130 100644--- a/crates/utopia-store/src/extraction_drops.rs+++ b/crates/utopia-store/src/extraction_drops.rs@@ -46,6 +46,23 @@ pub mod reason {/// OpenAI。事实不落,例句是那个短语;这一类该由提示词的规则改写到有名字的一侧,/// 这里只量它还错多少pub const SUBJECT_SHORTENED: &str = "subject_shortened";+ /// 主宾片段不在引文里(#582):模型没照抄。事实照旧处理,只记下来+ pub const SPAN_NOT_IN_QUOTE: &str = "span_not_in_quote";+ /// 主语片段是个描述,不是任何声明过的实体的名字:事实不落(#582,取代 #578 的词表)+ pub const SUBJECT_DESCRIBED: &str = "subject_described";+ /// 宾语片段是个描述:事实照落,宾语落成字面值(#582)+ pub const OBJECT_DESCRIBED: &str = "object_described";+ /// 片段点的是另一个声明过的实体:改绑到它(#582)+ pub const SPAN_REBOUND: &str = "span_rebound";+ /// 片段是所绑名字前面带了别的词("entrepreneur Tasha McCauley" / "companies using+ /// OpenAI"):头衔还是另一件东西,机器分不开,绑定照旧,只记(#582)+ pub const SPAN_PREFIXED: &str = "span_prefixed";+ /// 片段里没有任何声明过的名字("him" / "the company"):模型消解了指代,无从核对,+ /// 绑定照旧,只记(#582)+ pub const SPAN_COREFERENCE: &str = "span_coreference";+ /// 片段抄的是事实**另一侧**的名字(宾语片段写成了主语):抄错了位置,不是绑错了+ /// 实体。绑定照旧,只记(#582)+ pub const SPAN_MISPLACED: &str = "span_misplaced";/// 宾语既没在 entities 里声明、库里也没有叫这个名字的东西:事实照落,/// 宾语落成字面值而不是节点(#559)。记下来是为了量:这一类里有多少/// 本该是实体(模型漏报),有多少本来就是描述