Plan, apply and roll back changes to a production ontology, with a blast radius report and a proof an auditor can re-check.
Rust ai-nativedescription-logicsformal-verificationinfrastructure-as-codeisabelle-languageknowledge-graphleanlean4mcpmcp-serverontologyowlowl2reasoningrustshaclsparqltheorem-proving
feat: implement feedback-based weight learning for alignment signals (closes #9)
FABIOTESS5df9bde4db10
diff --git a/src/align.rs b/src/align.rsindex bd5a2702..9c278001 100644--- a/src/align.rs+++ b/src/align.rs@@ -518,20 +518,119 @@ impl AlignmentEngine {format!("<{}> <{}> <{}> .\n", source, predicate, target)}+ /// Signal names in weight-vector order.+ #[cfg(not(feature = "embeddings"))]+ const SIGNAL_NAMES: [&'static str; 6] = [+ "label_similarity", "property_overlap", "parent_overlap",+ "instance_overlap", "restriction_similarity", "neighborhood_similarity",+ ];++ #[cfg(feature = "embeddings")]+ const SIGNAL_NAMES: [&'static str; 7] = [+ "label_similarity", "property_overlap", "parent_overlap",+ "instance_overlap", "restriction_similarity", "neighborhood_similarity",+ "embedding_similarity",+ ];+/// Get learned weights from align_feedback, or defaults if not enough data.fn get_learned_weights(&self) -> Vec<f64> {let conn = self.db.conn();++ // Count only feedback rows that have signal values storedlet count: i64 = conn- .query_row("SELECT COUNT(*) FROM align_feedback", [], |r| r.get(0))+ .query_row(+ "SELECT COUNT(*) FROM align_feedback WHERE signals_json IS NOT NULL",+ [],+ |r| r.get(0),+ ).unwrap_or(0);if count < 10 {return Self::DEFAULT_WEIGHTS.to_vec();}- // For now, return defaults. Full learning requires storing per-signal values- // in align_feedback, which we add in the feedback task.- Self::DEFAULT_WEIGHTS.to_vec()+ // Compute per-signal acceptance rates via likelihood ratio.+ // For each signal, compute mean value in accepted vs rejected sets.+ // Signals where accepted-mean >> rejected-mean are more discriminative.+ let n_signals = Self::DEFAULT_WEIGHTS.len();+ let mut acc_sum = vec![0.0_f64; n_signals];+ let mut acc_count = 0_u32;+ let mut rej_sum = vec![0.0_f64; n_signals];+ let mut rej_count = 0_u32;++ let mut stmt = match conn.prepare(+ "SELECT accepted, signals_json FROM align_feedback WHERE signals_json IS NOT NULL"+ ) {+ Ok(s) => s,+ Err(_) => return Self::DEFAULT_WEIGHTS.to_vec(),+ };++ let rows = match stmt.query_map([], |row| {+ let accepted: i32 = row.get(0)?;+ let json_str: String = row.get(1)?;+ Ok((accepted, json_str))+ }) {+ Ok(r) => r,+ Err(_) => return Self::DEFAULT_WEIGHTS.to_vec(),+ };++ for row in rows.flatten() {+ let (accepted, json_str) = row;+ let signals: std::collections::HashMap<String, f64> = match serde_json::from_str(&json_str) {+ Ok(s) => s,+ Err(_) => continue,+ };++ let vals: Vec<f64> = Self::SIGNAL_NAMES+ .iter()+ .map(|name| signals.get(*name).copied().unwrap_or(0.0))+ .collect();++ if accepted != 0 {+ for (i, v) in vals.iter().enumerate() {+ acc_sum[i] += v;+ }+ acc_count += 1;+ } else {+ for (i, v) in vals.iter().enumerate() {+ rej_sum[i] += v;+ }+ rej_count += 1;+ }+ }++ // Need both accepted and rejected samples to learn+ if acc_count < 3 || rej_count < 3 {+ return Self::DEFAULT_WEIGHTS.to_vec();+ }++ // Compute discriminative power: ratio of accepted mean to rejected mean.+ // Clamp to avoid division by zero and extreme outliers.+ let mut raw_weights = vec![0.0_f64; n_signals];+ for i in 0..n_signals {+ let acc_mean = acc_sum[i] / acc_count as f64;+ let rej_mean = rej_sum[i] / rej_count as f64;+ // Likelihood ratio with Laplace smoothing+ let ratio = (acc_mean + 0.01) / (rej_mean + 0.01);+ raw_weights[i] = ratio.max(0.1).min(10.0);+ }++ // Blend with defaults (70% learned, 30% prior) for stability+ for i in 0..n_signals {+ raw_weights[i] = 0.7 * raw_weights[i] + 0.3 * Self::DEFAULT_WEIGHTS[i];+ }++ // Normalise to sum to 1.0+ let total: f64 = raw_weights.iter().sum();+ if total > 0.0 {+ for w in &mut raw_weights {+ *w /= total;+ }+ } else {+ return Self::DEFAULT_WEIGHTS.to_vec();+ }++ raw_weights}/// Record user feedback on an alignment candidate.@@ -541,20 +640,32 @@ impl AlignmentEngine {target_iri: &str,predicted_relation: &str,accepted: bool,+ signals: Option<&std::collections::HashMap<String, f64>>,) -> anyhow::Result<String> {let conn = self.db.conn();+ let signals_json = signals.map(|s| serde_json::to_string(s).unwrap_or_default());conn.execute(- "INSERT INTO align_feedback (source_iri, target_iri, predicted_relation, accepted)- VALUES (?1, ?2, ?3, ?4)",- rusqlite::params![source_iri, target_iri, predicted_relation, accepted as i32],+ "INSERT INTO align_feedback (source_iri, target_iri, predicted_relation, accepted, signals_json)+ VALUES (?1, ?2, ?3, ?4, ?5)",+ rusqlite::params![source_iri, target_iri, predicted_relation, accepted as i32, signals_json],)?;+ let feedback_count: i64 = conn+ .query_row(+ "SELECT COUNT(*) FROM align_feedback WHERE signals_json IS NOT NULL",+ [],+ |r| r.get(0),+ )+ .unwrap_or(0);+Ok(serde_json::json!({"ok": true,"source_iri": source_iri,"target_iri": target_iri,"predicted_relation": predicted_relation,"accepted": accepted,+ "feedback_count": feedback_count,+ "weights_learning": if feedback_count >= 10 { "active" } else { "collecting" },}).to_string())}}@@ -791,6 +902,7 @@ mod tests {"http://other.org/Canine","owl:equivalentClass",true,+ None,).unwrap();let parsed: serde_json::Value = serde_json::from_str(&result).unwrap();diff --git a/src/inputs.rs b/src/inputs.rsindex add5dedc..6ab9a676 100644--- a/src/inputs.rs+++ b/src/inputs.rs@@ -265,6 +265,8 @@ pub struct OntoAlignFeedbackInput {pub target_iri: String,/// Whether the alignment candidate was correctpub accepted: bool,+ /// Signal values from the alignment candidate (copied from the "signals" field in align output)+ pub signals: Option<std::collections::HashMap<String, f64>>,}#[derive(Deserialize, JsonSchema)]diff --git a/src/main.rs b/src/main.rsindex ecaf6933..b4322215 100644--- a/src/main.rs+++ b/src/main.rs@@ -1271,7 +1271,7 @@ async fn main() -> anyhow::Result<()> {let (db, graph) = setup(&cli.data_dir)?;let engine = open_ontologies::align::AlignmentEngine::new(db, graph);let accepted = accept || !reject;- let result = engine.record_feedback(&source, &target, "user_feedback", accepted)+ let result = engine.record_feedback(&source, &target, "user_feedback", accepted, None).unwrap_or_else(|e| format!(r#"{{"error":"{}"}}"#, e));output_result(&result, cli.pretty);}diff --git a/src/server.rs b/src/server.rsindex 6fd65483..941324c0 100644--- a/src/server.rs+++ b/src/server.rs@@ -903,7 +903,7 @@ impl OpenOntologiesServer {#[tool(name = "onto_align_feedback", description = "Accept or reject an alignment candidate to improve future confidence scoring. Stores feedback in align_feedback table for self-calibrating weights.")]async fn onto_align_feedback(&self, Parameters(input): Parameters<OntoAlignFeedbackInput>) -> String {let engine = crate::align::AlignmentEngine::new(self.db.clone(), self.graph.clone());- match engine.record_feedback(&input.source_iri, &input.target_iri, "user_feedback", input.accepted) {+ match engine.record_feedback(&input.source_iri, &input.target_iri, "user_feedback", input.accepted, input.signals.as_ref()) {Ok(result) => {self.lineage().record(&self.session_id, "AF", "align_feedback", if input.accepted { "accepted" } else { "rejected" });resultdiff --git a/src/state.rs b/src/state.rsindex cc89ca10..25878a0a 100644--- a/src/state.rs+++ b/src/state.rs@@ -80,6 +80,7 @@ CREATE TABLE IF NOT EXISTS align_feedback (target_iri TEXT NOT NULL,predicted_relation TEXT NOT NULL,accepted INTEGER NOT NULL,+ signals_json TEXT,timestamp TEXT NOT NULL DEFAULT (datetime('now')));@@ -123,6 +124,10 @@ impl StateDb {"ALTER TABLE monitor_watchers ADD COLUMN webhook_url TEXT;ALTER TABLE monitor_watchers ADD COLUMN webhook_headers TEXT;");+ // Safe migration: add signals_json column for feedback-based weight learning+ let _ = conn.execute_batch(+ "ALTER TABLE align_feedback ADD COLUMN signals_json TEXT;"+ );Ok(Self {conn: Arc::new(Mutex::new(conn)),})