Skip to content

World's first open-source enterprise world model.

A quantity is never an entity (#587)

WaylandYangffbb24bd7fa0
diff --git a/crates/utopia-extract/src/lib.rs b/crates/utopia-extract/src/lib.rs
index 6478789d..199a48ae 100644
--- a/crates/utopia-extract/src/lib.rs
+++ b/crates/utopia-extract/src/lib.rs
@@ -809,6 +809,57 @@ pub fn parse_quantity(s: &str) -> Option<(f64, Option<String>)> {
Some((n, unit))
}
+/// 开头是一个量、后面还挂着词的 → 那个量。`"1,250 people"` → (1250, "people")。
+///
+/// **这是给已经知道要什么的地方用的**,与 `parse_quantity` 的严不是一回事。
+/// `parse_quantity` 要判「这串字是不是一个东西」,判错就把一个真实体吃掉,
+/// 所以尾巴上有实词一律不认。而这里的调用方手上已经有一条声明了
+/// `datatype = number` 的属性——问的不再是「是不是数」,是「那个数是多少」,
+/// 判错的代价只是一个值不对,量级差着好几档。
+///
+/// 实测卡住的正是这一格:本体里有 `employeeCount (number)`、事实写着
+/// `employee_count → "1,250 people"`,词对得上、属性也在,只因为模型把单位
+/// 写进了值里就一直换不动,那条事实永远拿不到谓词。
+pub fn parse_leading_quantity(s: &str) -> Option<(f64, Option<String>)> {
+ let s = s.trim();
+ // 整体就是一个量的先按严的那套解——`$5 billion` 的单位是 `$` 不是 `billion`
+ if let Some(hit) = parse_quantity(s) {
+ return Some(hit);
+ }
+ let mut parts = s.split_whitespace();
+ let head = parts.next()?;
+ // 数字与紧跟着的百分号/单位可能不分家:`42%`、`8GW`
+ let split = head
+ .char_indices()
+ .find(|(_, c)| !matches!(c, '0'..='9' | '.' | ',' | '_' | '-' | '+'))
+ .map(|(i, _)| i)
+ .unwrap_or(head.len());
+ let (num, glued) = head.split_at(split);
+ let cleaned: String = num.chars().filter(|c| !matches!(c, ',' | '_')).collect();
+ let n: f64 = cleaned.parse().ok()?;
+ if !n.is_finite() {
+ return None;
+ }
+ // 紧贴着的记号优先当单位(`42%` → `%`),否则取后面第一个词
+ let mut rest = parts;
+ let (scale, unit) = if glued.is_empty() {
+ match rest.next() {
+ None => (1.0, None),
+ Some(w) => match w.to_ascii_lowercase().as_str() {
+ "thousand" => (1e3, rest.next().map(str::to_string)),
+ "million" => (1e6, rest.next().map(str::to_string)),
+ "billion" => (1e9, rest.next().map(str::to_string)),
+ "trillion" => (1e12, rest.next().map(str::to_string)),
+ _ => (1.0, Some(w.to_string())),
+ },
+ }
+ } else {
+ (1.0, Some(glued.to_string()))
+ };
+ let n = n * scale;
+ n.is_finite().then_some((n, unit))
+}
+
/// 属性值按 datatype 归一。失败返回 None——宁缺勿脏,调用方跳过并记日志。
/// number 容忍千分位/空格;date 要求 YYYY[-MM[-DD]] 且保留原精度;bool 宽容 yes/no。
pub fn normalize_attr_value(datatype: &str, raw: &serde_json::Value) -> Option<serde_json::Value> {
@@ -826,7 +877,11 @@ pub fn normalize_attr_value(datatype: &str, raw: &serde_json::Value) -> Option<s
// 清洗解不动的再当量解:`$5 billion`、`52%` 这些整体就是数,
// 只是带着符号与量级词。单位不在这里落笔——它随事实走
// (见 `parse_quantity`),这一档只负责把值变成可比的数
- .or_else(|| parse_quantity(s).map(|(n, _)| n))
+ // 清洗解不动的再当量解。**这一档已经声明了 datatype = number**,
+ // 问的不是「是不是数」而是「那个数是多少」,所以用宽的那套:
+ // `$5 billion` → 5e9,`1,250 people` → 1250,
+ // `42% from customers in Europe` → 42
+ .or_else(|| parse_leading_quantity(s).map(|(n, _)| n))
.filter(|f| f.is_finite())
.and_then(serde_json::Number::from_f64)
.map(serde_json::Value::Number)
@@ -1125,6 +1180,40 @@ mod tests {
assert_eq!(parse_quantity("杭州"), None);
}
+ #[test]
+ fn a_declared_number_reads_past_the_unit() {
+ // 属性已经声明了 datatype = number,问的是「那个数是多少」。
+ // 卡住过的两条都在这里
+ assert_eq!(
+ parse_leading_quantity("1,250 people"),
+ Some((1250.0, Some("people".into())))
+ );
+ assert_eq!(
+ parse_leading_quantity("42% from customers in Europe"),
+ Some((42.0, Some("%".into())))
+ );
+ assert_eq!(
+ parse_leading_quantity("3,400 people worldwide"),
+ Some((3400.0, Some("people".into())))
+ );
+ assert_eq!(
+ parse_leading_quantity("900 million weekly active users"),
+ Some((9e8, Some("weekly".into())))
+ );
+ // 整体就是量的仍走严的那套:单位是 `$`,不是 `billion`
+ assert_eq!(
+ parse_leading_quantity("$5 billion"),
+ Some((5e9, Some("$".into())))
+ );
+ // 开头不是数就还是不认
+ assert_eq!(parse_leading_quantity("about ten"), None);
+ assert_eq!(parse_leading_quantity(""), None);
+
+ // **严的那套一点没松**:它要判「是不是一个东西」,判错会吃掉真实体
+ assert_eq!(parse_quantity("1,250 people"), None);
+ assert_eq!(parse_quantity("2025 Atlantic hurricane season"), None);
+ }
+
#[test]
fn a_number_attribute_takes_a_written_quantity() {
use serde_json::json;
diff --git a/crates/utopia-server/src/api/ontology_routes.rs b/crates/utopia-server/src/api/ontology_routes.rs
index 435cca91..6a215b60 100644
--- a/crates/utopia-server/src/api/ontology_routes.rs
+++ b/crates/utopia-server/src/api/ontology_routes.rs
@@ -1391,6 +1391,43 @@ pub(crate) struct AttributeAdopted {
}
/// 建(或指向已有的)属性,并把等着它的字面值事实改挂过去。人工与自动共用。
+/// 等着这个说法的值**是不是清一色的量**;是的话给出它们共同的单位。
+///
+/// 判据要全体一致:混着 `$12 billion` 与 `chief executive` 的一批,
+/// 按 number 落地会把后者整条丢掉(换不动的不改写),那不如老实当 text。
+fn quantity_shape(facts: &[(Uuid, Option<Uuid>, serde_json::Value)]) -> Option<String> {
+ if facts.is_empty() {
+ return None;
+ }
+ let mut unit: Option<String> = None;
+ let mut agreed = true;
+ for (_, _, v) in facts {
+ let raw = v.get("value").unwrap_or(v);
+ let hit = match raw {
+ serde_json::Value::Number(_) => Some((0.0, None)),
+ serde_json::Value::String(s) => utopia_extract::parse_leading_quantity(s),
+ _ => None,
+ }?;
+ // 抽取那一步单记的单位更可信(`$5 billion` → `$`),没有再退回解出来的
+ let u = v
+ .get("unit")
+ .and_then(|u| u.as_str())
+ .map(str::to_string)
+ .or(hit.1);
+ match (&unit, u) {
+ (None, Some(u)) => unit = Some(u),
+ (Some(a), Some(b)) if *a != b => agreed = false,
+ _ => {}
+ }
+ }
+ // 全体都是量才走到这里;单位不一致就当没有单位,别挑一个塞上去
+ Some(if agreed {
+ unit.unwrap_or_default()
+ } else {
+ String::new()
+ })
+}
+
pub(crate) async fn adopt_attribute_core(
state: &AppState,
kb_id: Uuid,
@@ -1419,7 +1456,16 @@ pub(crate) async fn adopt_attribute_core(
"nothing is waiting on those wordings",
));
}
- utopia_store::ontology::create_relation_type(
+ /* **datatype 由等着的那些值定,不听模型的。**
+ 实测模型给 `valuation` 报的是 text,而等它的四个值全是
+ `$12 billion` 这样的量;存成 text 就比不了大小——而"能比大小"
+ 正是这些数不该当节点的理由。手里有事实的时候不必去问判断题,
+ `keep_forms` 那里已经是同一个原则。
+ 单位同理:几条值的单位一致就落在属性上(`$`、`%`、`people`)。 */
+ let inferred = quantity_shape(&facts);
+ let datatype = inferred.as_ref().map_or(spec.datatype, |_| "number");
+ let unit = inferred.as_deref().filter(|u| !u.is_empty()).or(spec.unit);
+ match utopia_store::ontology::create_relation_type(
&state.pool,
kb_id,
spec.key,
@@ -1432,10 +1478,34 @@ pub(crate) async fn adopt_attribute_core(
"attribute",
&domains,
&[],
- Some(spec.datatype),
- spec.unit,
+ Some(datatype),
+ unit,
)
- .await?
+ .await
+ {
+ Ok(id) => id,
+ /* 键被一个**空的**同名关系占着:改判它,别放弃。
+ 实测就是这么卡住的——`Relation key 'valuation' already exists`,
+ 然后 valuation 那几个数额永远没有谓词,而那条关系自己一条事实
+ 都没有。有事实的不会被改判(判据在 store 那一侧的 SQL 里),
+ 那种是本体与语料的真分歧,照旧报错留给人看 */
+ Err(e) => match utopia_store::ontology::attribute_from_unused_relation(
+ &state.pool,
+ kb_id,
+ spec.key,
+ &domains,
+ datatype,
+ unit,
+ )
+ .await?
+ {
+ Some(id) => {
+ tracing::info!(%kb_id, key = spec.key, "空关系改判成属性");
+ id
+ }
+ None => return Err(e),
+ },
+ }
};
// 换算按**库里那一条**的 datatype,不按请求——指向已有属性时请求里根本
diff --git a/crates/utopia-server/src/bootstrap_ontology.rs b/crates/utopia-server/src/bootstrap_ontology.rs
index 628245c6..1c0922b0 100644
--- a/crates/utopia-server/src/bootstrap_ontology.rs
+++ b/crates/utopia-server/src/bootstrap_ontology.rs
@@ -203,9 +203,21 @@ pub async fn bootstrap_ontology(state: &AppState, kb_id: Uuid) -> anyhow::Result
.filter(|f| f.doc_count >= MIN_DOCS)
.collect();
let types = utopia_store::resolution::proposed_types(&state.pool, kb_id).await?;
- if forms.len() + types.len() < MIN_SIGNALS {
+ /* **字面值那一档也要算进来。**
+ `proposed_predicates` 只数宾语是实体的事实(它数的是"采纳要改写的东西"),
+ 于是一个满是数额的语料在这里算出 predicates=0,整个自动扩本体被跳过,
+ 下面那段建属性的代码一次都跑不到。实测:12 条带着 `valuation`、
+ `investment_amount` 等说法的值事实在库里等着,日志里只有一行
+ 「够格的信号太少」。它们同样是"够不够一次 LLM 调用的量"的信号 */
+ let value_forms: Vec<_> = utopia_store::graph::proposed_attributes(&state.pool, kb_id)
+ .await?
+ .into_iter()
+ .filter(|f| f.doc_count >= MIN_DOCS)
+ .collect();
+ if forms.len() + types.len() + value_forms.len() < MIN_SIGNALS {
tracing::debug!(
%kb_id, predicates = forms.len(), types = types.len(),
+ values = value_forms.len(),
"够格的信号太少,跳过自动扩本体"
);
return Ok(());
diff --git a/crates/utopia-server/src/extraction.rs b/crates/utopia-server/src/extraction.rs
index 4ec9453d..c89c9254 100644
--- a/crates/utopia-server/src/extraction.rs
+++ b/crates/utopia-server/src/extraction.rs
@@ -426,6 +426,21 @@ fn is_entity_name(name: &str) -> bool {
{
return false;
}
+ /* **整体就是一个量的,不是一个东西**:`$5 billion`、`52%`、`3.5 million`。
+ 上面那条部分格只接住 `745 of …`,接不住这些。
+
+ 这道闸装在**这里**才管用。抽取那边也有一道(`looks_literal`),但它前面
+ 挂着 `!known_predicate`:谓词一旦是本体里列出来的关系,整段判断直接跳过。
+ 实测就是这么漏的——`hasAmount` 来自 FIBO 包、抽取前就在本体里,于是
+ `Microsoft hasAmount $1 billion` 里那个数额照样被造成了节点,
+ 而同一个库里 `invested`(语料自己长的、当时还未知)走到了那道闸、被拦下。
+ `is_entity_name` 不问谓词,主语宾语一视同仁,两条路都过它。
+
+ 判据仍旧从严(见 `parse_quantity`):尾巴上有实词就不算,
+ `3M`、`7-Eleven`、`23andMe`、`2025 Atlantic hurricane season` 一个都不误伤。 */
+ if utopia_extract::parse_quantity(name).is_some() {
+ return false;
+ }
true
}
@@ -1556,6 +1571,23 @@ async fn run(state: &AppState, document_id: Uuid, proposer: Proposer) -> anyhow:
// 值在手上就收下,原词进 proposed_predicate,等本体采纳时再换谓词,
// 形状已经是对的(0010)
(Some(v), None | Some("")) => Some(v.clone()),
+ /* **宾语整体是一个量:一律当值收下**,不问谓词认不认识、
+ 也不问模型有没有把它声明成实体。
+
+ 下面那一档卡着 `!known_predicate`,理由是本体说得上话的时候
+ 别去二猜模型。可量值这里没有可猜的余地:一个数额不会因为
+ 谓词恰好在本体里就变成一个东西。实测漏的正是这一格——
+ `hasAmount` 来自 FIBO 包、抽取前就在本体里,
+ `Microsoft hasAmount $1 billion` 于是绕过下面那一档,
+ 把数额造成了节点;同一个库里 `invested` 当时还未知,
+ 走到下面那一档、被拦住了。同一个数额,两种下场。
+
+ 收下而不是丢掉:`is_entity_name` 那道闸现在也拦纯量值,
+ 不在这里接住的话,这条事实会连同那个数一起进丢弃表。
+ 原词照旧进 `proposed_predicate`,采纳时再换谓词 */
+ (_, Some(o)) if utopia_extract::parse_quantity(o).is_some() => {
+ Some(serde_json::Value::String(o.to_string()))
+ }
(_, Some(o))
if !o.is_empty()
&& !known_predicate(f.predicate.as_str())
@@ -2736,6 +2768,32 @@ mod name_tests {
}
}
+ /// 一个数额不是一个东西。
+ ///
+ /// 样本取自实跑出来的库:`$5 billion`、`$1 billion`、`$30 billion` 各自成过节点,
+ /// 而且同名的会并成一个点——SSI Inc. 与 Nvidia 因为都出现过「$5 billion」
+ /// 在图上相连,那条路径没有任何含义。判据的窄处在**尾巴**:
+ /// 后面还有实词的一律放行,因为那时它说的就不再只是那个数。
+ #[test]
+ fn a_quantity_is_not_a_thing() {
+ for s in ["$5 billion", "€1.5 million", "52%", "3.5 million", "35,000"] {
+ assert!(!is_entity_name(s), "这是一个量,不该当成实体名:{s}");
+ }
+ // **以数字开头的真实体一个都不能误伤。** 量级词只认全写,所以 `3M` 解不动;
+ // 后面挂着实词的,尾巴那一条接住
+ for s in [
+ "3M",
+ "7-Eleven",
+ "23andMe",
+ "2025 Atlantic hurricane season",
+ "900 million weekly active users",
+ "1000 Islands",
+ "$10 billion investment",
+ ] {
+ assert!(is_entity_name(s), "这是真实体,不该被挡:{s}");
+ }
+ }
+
/// **真实体会长,但不带谓语。** 判据是词数 + 限定动词,不是字符数——
/// 下面第一个 57 字符,比上面那条 65 字符的从句还短不了多少
#[test]
diff --git a/crates/utopia-store/src/ontology.rs b/crates/utopia-store/src/ontology.rs
index 9c5e21f4..f70697b8 100644
--- a/crates/utopia-store/src/ontology.rs
+++ b/crates/utopia-store/src/ontology.rs
@@ -1251,6 +1251,45 @@ pub async fn relation_type_id_by_key(
Ok(row.map(|(id,)| id))
}
+/// 一个**从没当关系用过**的关系,改判成属性。改成了返回 true。
+///
+/// 冷启动认出某个说法该是属性、去建的时候,键可能已经被一个同名关系占着
+/// (实测:`Relation key 'valuation' already exists`,然后整批放弃,那些数
+/// 永远拿不到谓词)。可占着这个键的关系常常是空的——本体包带进来的、或者
+/// 早先按票数建的,一条事实都没挂上。空的关系改判不破坏任何东西:
+/// 没有边会因此断,撤销也只是再改回去。
+///
+/// **有事实的一律不动**。`invested`、`raised` 这类既连实体又带数额的,
+/// 改判会把已有的边连根拔起;那是本体与语料的真分歧,该留给人看,
+/// 不该由冷启动替人决定。
+pub async fn attribute_from_unused_relation(
+ pool: &PgPool,
+ kb_id: Uuid,
+ key: &str,
+ domains: &[Uuid],
+ datatype: &str,
+ unit: Option<&str>,
+) -> AppResult<Option<Uuid>> {
+ validate_attribute_fields("attribute", domains, Some(datatype))?;
+ let row: Option<(Uuid,)> = sqlx::query_as(
+ "UPDATE relation_types SET kind = 'attribute', datatype = $3, unit = $4,
+ inverse_of = NULL, sub_property_of = NULL
+ WHERE kb_id = $1 AND key = $2 AND kind = 'relation'
+ AND NOT EXISTS (SELECT 1 FROM facts f WHERE f.predicate_id = relation_types.id)
+ RETURNING id",
+ )
+ .bind(kb_id)
+ .bind(key)
+ .bind(datatype)
+ .bind(unit)
+ .fetch_optional(pool)
+ .await?;
+ let Some((id,)) = row else { return Ok(None) };
+ // domain / range 在各自的表里,不是列。属性没有 range——值域落在 datatype 上
+ set_domains_ranges(pool, id, domains, &[]).await?;
+ Ok(Some(id))
+}
+
/// 一个属性声明的 datatype。改写字面值事实时要按它换算。
///
/// 以**库里这一条**为准而不是以请求为准:指向已有属性时请求里根本没有