From 0baac9939cb3865d576d2c7678d038618de16d50 Mon Sep 17 00:00:00 2001 From: Kristofferjoha Date: Fri, 20 Nov 2026 12:51:15 +0100 Subject: [PATCH 1/4] check --- .../backend/engine/teacher/objective.hpp | 14 +- .../backend/engine/teacher/teacher.hpp | 20 +- engine/src/teacher/objective.cpp | 142 ++++++++-- engine/src/teacher/teacher.cpp | 251 +++++++++++++++++- engine/tests/teacher/teacher_test.cpp | 182 ++++++++++--- 5 files changed, 534 insertions(+), 75 deletions(-) diff --git a/engine/include/backend/engine/teacher/objective.hpp b/engine/include/backend/engine/teacher/objective.hpp index e797269..c8a8c2f 100644 --- a/engine/include/backend/engine/teacher/objective.hpp +++ b/engine/include/backend/engine/teacher/objective.hpp @@ -280,9 +280,17 @@ class KnnState { // Whether i's choice can change the metric: watched, or with compressed queries a query bool active(std::size_t i) const; // Original queries only. From every query watching i, in the order propose and apply expect - std::vector distances(std::size_t i, const core::TrajectoryView &candidate) const; + std::vector distances(std::size_t i, const core::TrajectoryView &candidate, + bool parallel = false) const; // Change in J_T double propose(std::size_t i, std::span distances) const; + // The same change from i becoming candidate, computing a distance only near a query's k-th + // place + double propose_bounded(std::size_t i, const core::TrajectoryView &candidate) const; + // Original queries only. Adds trajectory i to the list of every query that one of versions[i] + // comes within the query's watch radius of, the distance of its watch-th nearest in state + void watch(std::span> versions, + std::span state); void apply(std::size_t i, std::span distances); // Either query kind. With compressed queries a distance depends on both sides, so a move also @@ -307,12 +315,16 @@ class KnnState { std::size_t hits(std::size_t e, std::size_t position, double distance) const; // The same with e's whole row replaced std::size_t hits(std::size_t e, std::span row) const; + // True neighbours in the top k of order (distance, position) + std::size_t ranked_hits(std::size_t e, + std::vector> &order) const; // Distances from query, e in some state, to e's list in state std::vector own_row(std::size_t e, const core::TrajectoryView &query, std::span state) const; const Objective &m_objective; std::size_t m_valid = 0; + std::size_t m_watch = 0; std::vector> m_list; // per query, its true top k first std::vector> m_distance; // per query, in list order std::vector m_hits; // per query diff --git a/engine/include/backend/engine/teacher/teacher.hpp b/engine/include/backend/engine/teacher/teacher.hpp index ad7a0b3..ce4c2ef 100644 --- a/engine/include/backend/engine/teacher/teacher.hpp +++ b/engine/include/backend/engine/teacher/teacher.hpp @@ -27,17 +27,19 @@ namespace teacher { // BUDGET_LOOP_REALLOCATE then curves, budgets and loop again while J_T rises. With only // held-out join terms the curves ignore partners, so this only reruns // the loop in a new visit order +// BUDGET_LOOP_TRADE then moves points between trajectories while exact J_T rises // BUDGET_LOOP_SHUFFLED control: loop on relabelled partners and neighbours // BUDGET_LOOP_NO_UPDATE control: one pass against the starting state -inline constexpr std::array kArms{"EQUAL_CHOICE", - "EQUAL_CHOICE_RDP_PARTNERS", - "EQUAL_LOOP", - "BUDGET_RDP", - "BUDGET_CHOICE", - "BUDGET_LOOP", - "BUDGET_LOOP_REALLOCATE", - "BUDGET_LOOP_SHUFFLED", - "BUDGET_LOOP_NO_UPDATE"}; +inline constexpr std::array kArms{"EQUAL_CHOICE", + "EQUAL_CHOICE_RDP_PARTNERS", + "EQUAL_LOOP", + "BUDGET_RDP", + "BUDGET_CHOICE", + "BUDGET_LOOP", + "BUDGET_LOOP_REALLOCATE", + "BUDGET_LOOP_TRADE", + "BUDGET_LOOP_SHUFFLED", + "BUDGET_LOOP_NO_UPDATE"}; bool is_arm(std::string_view name); // Throws std::invalid_argument on an unknown or repeated arm diff --git a/engine/src/teacher/objective.cpp b/engine/src/teacher/objective.cpp index 61f71d6..2e34552 100644 --- a/engine/src/teacher/objective.cpp +++ b/engine/src/teacher/objective.cpp @@ -72,6 +72,8 @@ double range_marginal(std::size_t others, std::size_t expected, std::size_t scor } constexpr std::size_t kMaxJoinTerms = 8; +// query::frechet_distance's continuous search tolerance +constexpr double kKnnDistanceError = 1e-3; double f1_of(std::size_t hits, std::size_t found, std::size_t expected) { return 2.0 * static_cast(hits) / static_cast(found + expected); @@ -700,7 +702,7 @@ void JoinState::apply(const Proposal &proposal) { KnnState::KnnState(const Objective &objective, const KeptSets &state, std::span watch_states, std::size_t watch) - : m_objective(objective) { + : m_objective(objective), m_watch(watch) { const auto &db = objective.db(); const auto &workloads = objective.workloads(); const std::size_t n = db.size(); @@ -753,14 +755,20 @@ KnnState::KnnState(const Objective &objective, const KeptSets &state, m_hit_sum = std::accumulate(m_hits.begin(), m_hits.end(), 0ul); } -std::vector KnnState::distances(std::size_t i, - const core::TrajectoryView &candidate) const { +std::vector KnnState::distances(std::size_t i, const core::TrajectoryView &candidate, + bool parallel) const { const auto &db = m_objective.db(); - std::vector result; - result.reserve(m_watchers[i].size()); - for (const auto &watcher : m_watchers[i]) - result.push_back(query::frechet_distance(db.trajectory(watcher.query), candidate, - m_objective.workloads().frechet)); + const auto &watchers = m_watchers[i]; + std::vector result(watchers.size()); + auto one = [&](std::size_t s) { + result[s] = query::frechet_distance(db.trajectory(watchers[s].query), candidate, + m_objective.workloads().frechet); + }; + if (parallel) + core::parallel_for(watchers.size(), one); + else + for (std::size_t s = 0; s < watchers.size(); ++s) + one(s); return result; } @@ -815,29 +823,24 @@ void KnnState::apply(const Move &move) { } std::size_t KnnState::hits(std::size_t e, std::span row) const { - const auto &list = m_list[e]; - const std::size_t k = std::min(m_objective.workloads().k, list.size()); - const std::size_t members = m_objective.workloads().knn[e].top.size(); - std::vector> order(list.size()); - for (std::size_t p = 0; p < list.size(); ++p) + std::vector> order(m_list[e].size()); + for (std::size_t p = 0; p < order.size(); ++p) order[p] = {row[p], static_cast(p)}; - std::ranges::partial_sort( - order, order.begin() + static_cast(k), [&](const auto &a, const auto &b) { - return a.first < b.first || (a.first == b.first && list[a.second] < list[b.second]); - }); - std::size_t count = 0; - for (std::size_t p = 0; p < k; ++p) - count += order[p].second < members; - return count; + return ranked_hits(e, order); } std::size_t KnnState::hits(std::size_t e, std::size_t position, double distance) const { + std::vector> order(m_list[e].size()); + for (std::size_t p = 0; p < order.size(); ++p) + order[p] = {p == position ? distance : m_distance[e][p], static_cast(p)}; + return ranked_hits(e, order); +} + +std::size_t KnnState::ranked_hits(std::size_t e, + std::vector> &order) const { const auto &list = m_list[e]; const std::size_t k = std::min(m_objective.workloads().k, list.size()); const std::size_t members = m_objective.workloads().knn[e].top.size(); - std::vector> order(list.size()); - for (std::size_t p = 0; p < list.size(); ++p) - order[p] = {p == position ? distance : m_distance[e][p], static_cast(p)}; // Ties go to the lower database index, like query::knn std::ranges::partial_sort( order, order.begin() + static_cast(k), [&](const auto &a, const auto &b) { @@ -849,6 +852,97 @@ std::size_t KnnState::hits(std::size_t e, std::size_t position, double distance) return count; } +void KnnState::watch(std::span> versions, + std::span state) { + if (m_objective.config().compressed_knn_query) + throw std::logic_error("knn state: watch needs original queries"); + const auto &db = m_objective.db(); + const auto frechet = m_objective.workloads().frechet; + const std::size_t n = db.size(); + std::vector radius(n, -1.0); + core::parallel_for(n, [&](std::size_t e) { + if (m_list[e].empty()) + return; + auto distances = m_distance[e]; + const auto at = distances.begin() + + static_cast(std::min(m_watch, distances.size()) - 1); + std::ranges::nth_element(distances, at); + radius[e] = *at; + }); + // A version keeps i's endpoints, so the endpoint bound rules out most queries for all of them + std::vector>> added(n); + core::parallel_for(n, [&](std::size_t i) { + if (versions[i].empty()) + return; + const auto original = db.trajectory(i); + for (std::size_t e = 0; e < n; ++e) { + if (radius[e] < 0 || e == i || + query::endpoint_lower_bound(db.trajectory(e), original) > radius[e] || + std::ranges::any_of(m_watchers[i], [&](const Watcher &w) { return w.query == e; })) + continue; + for (const auto &version : versions[i]) + if (query::frechet_within(db.trajectory(e), version, radius[e], frechet)) { + added[i].push_back( + {static_cast(e), + query::frechet_distance(db.trajectory(e), state[i], frechet)}); + break; + } + } + }); + std::vector touched(n, 0); + for (std::size_t i = 0; i < n; ++i) + for (const auto &[e, distance] : added[i]) { + m_watchers[i].push_back({e, static_cast(m_list[e].size())}); + m_list[e].push_back(static_cast(i)); + m_distance[e].push_back(distance); + touched[e] = 1; + } + for (std::size_t e = 0; e < n; ++e) + if (touched[e]) { + m_hit_sum -= m_hits[e]; + m_hits[e] = hits(e, m_list[e].size(), 0.0); + m_hit_sum += m_hits[e]; + } +} + +double KnnState::propose_bounded(std::size_t i, const core::TrajectoryView &candidate) const { + if (m_objective.config().compressed_knn_query) + throw std::logic_error("knn state: propose_bounded needs original queries"); + const auto &db = m_objective.db(); + const auto frechet = m_objective.workloads().frechet; + const std::size_t k = m_objective.workloads().k; + // Clear of the k-th place by more than the stored distances' error + constexpr double margin = 2.5 * kKnnDistanceError; + long change = 0; + std::vector others; + for (const auto &[e, position] : m_watchers[i]) { + const auto inside = hits(e, position, -1.0); + const auto outside = hits(e, position, std::numeric_limits::infinity()); + std::size_t now = inside; + if (inside != outside) { + // The k-th distance among the others: i is in clearly below it, out clearly above + others.clear(); + for (std::size_t p = 0; p < m_list[e].size(); ++p) + if (p != position) + others.push_back(m_distance[e][p]); + const auto kth = + others.begin() + static_cast(std::min(k, others.size()) - 1); + std::ranges::nth_element(others, kth); + const auto query = db.trajectory(e); + if (*kth - margin > 0 && + query::frechet_within(query, candidate, *kth - margin, frechet)) + now = inside; + else if (!query::frechet_within(query, candidate, *kth + margin, frechet)) + now = outside; + else + now = hits(e, position, query::frechet_distance(query, candidate, frechet)); + } + change += static_cast(now) - static_cast(m_hits[e]); + } + return m_objective.scale(Objective::Knn) * static_cast(change) / + static_cast(k * m_valid); +} + double KnnState::propose(std::size_t i, std::span distances) const { long change = 0; for (std::size_t s = 0; s < m_watchers[i].size(); ++s) { diff --git a/engine/src/teacher/teacher.cpp b/engine/src/teacher/teacher.cpp index 5e39440..3937ce8 100644 --- a/engine/src/teacher/teacher.cpp +++ b/engine/src/teacher/teacher.cpp @@ -42,6 +42,8 @@ constexpr std::array kCandidates{ constexpr std::size_t kMaxResponsePasses = 10; constexpr std::size_t kKnnWatchFactor = 3; constexpr std::size_t kMaxAllocationRounds = 10; +constexpr std::array kTradeSteps{1, 2, 4}; // points moved per trade +constexpr std::size_t kMaxTradeRounds = 3; constexpr double kMinImprovement = 1e-12; // candidates[c][i]: trajectory i simplified by kCandidates[c] at budgets[i] @@ -293,9 +295,12 @@ class Search { Search(const core::TrajectoryDb &db, const Objective &objective, const Candidates &candidates, const Methods &method) : m_start(method), m_compressed_queries(objective.config().compressed_knn_query) { + auto start = std::chrono::steady_clock::now(); if (objective.config().ranking_knn) m_knn.emplace(objective, assemble(candidates, method), candidates, kKnnWatchFactor * objective.workloads().k); + const double knn_s = core::seconds_since(start); + start = std::chrono::steady_clock::now(); const auto active = [&](std::size_t i) { return !objective.boxes(i).empty() || !objective.links(i).empty() || (m_knn && m_knn->active(i)); @@ -328,7 +333,7 @@ class Search { m_views[c][i] = owned.back().view(); m_separable[i][c] = objective.separable(i, m_views[c][i]); // Compressed queries depend on the partners' state, so are computed later - if (m_knn && !objective.config().compressed_knn_query) + if (m_knn && !m_compressed_queries) m_knn_distances[i][c] = m_knn->distances(i, m_views[c][i]); } else { m_views[c][i] = m_views[first][i]; @@ -341,6 +346,8 @@ class Search { m_state[i] = m_views[method[i]][i]; m_join.emplace(objective, m_state); m_range.emplace(objective, m_state); + std::cout << std::format("teacher: loop setup: kNN lists {:.1f} s, candidates {:.1f} s\n", + knn_s, core::seconds_since(start)); } Search(const Search &) = delete; Search &operator=(const Search &) = delete; @@ -356,6 +363,7 @@ class Search { std::mt19937_64 rng(seed + kOrderSeedOffset); for (std::size_t pass = 1; pass <= kMaxResponsePasses; ++pass) { + const auto start = std::chrono::steady_clock::now(); std::ranges::shuffle(order, rng); std::size_t switches = 0; for (const auto i : order) { @@ -405,9 +413,10 @@ class Search { else if (knn) knn->apply(i, m_knn_distances[i][best]); } - std::cout << std::format("teacher: pass {}: {} switches, join F1 {:.4f}{}\n", pass, - switches, join.metric(), - knn ? std::format(", knn {:.4f}", knn->metric()) : ""); + std::cout << std::format( + "teacher: pass {}: {} switches, join F1 {:.4f}{}, {:.1f} s\n", pass, switches, + join.metric(), knn ? std::format(", knn {:.4f}", knn->metric()) : "", + core::seconds_since(start)); if (switches == 0 || !update) break; } @@ -435,6 +444,227 @@ Methods best_response(const core::TrajectoryDb &db, const Objective &objective, return Search(db, objective, candidates, method).run(seed, update); } +struct Traded { + KeptSets kept; + double value; +}; + +// Moves delta points between trajectories while exact J_T rises. Each round scores every +// trajectory's best recipe at b + delta and b - delta against the current state, pairs the best +// buyers with the cheapest sellers, and keeps a pair only if its exact gain, rescored when applied, +// is positive. Each round the kNN lists are extended to watch the offered versions +Traded trade_budgets(const core::TrajectoryDb &db, const Objective &objective, + const std::vector &caps, KeptSets kept) { + const std::size_t n = db.size(); + const bool ranking = objective.config().ranking_knn; + const bool compressed = objective.config().compressed_knn_query; + std::vector owned; + owned.reserve(n); + for (std::size_t i = 0; i < n; ++i) + owned.emplace_back(db.trajectory(i), kept[i]); + std::vector state(n); + for (std::size_t i = 0; i < n; ++i) + state[i] = owned[i].view(); + JoinState join(objective, state); + RangeState range(objective, state); + std::vector separable(n); + core::parallel_for(n, [&](std::size_t i) { separable[i] = objective.separable(i, state[i]); }); + std::optional knn; + + struct Pending { + std::size_t i; + PreparedTrajectory prepared; + std::vector kept; + double separable = 0.0, gain = 0.0; + JoinState::Proposal join; + RangeState::Proposal range; + KnnState::Move move; + std::vector distances; + }; + auto pending = [&](std::size_t i, std::vector next) { + Pending p{ + i, PreparedTrajectory(db.trajectory(i), next), std::move(next), 0.0, 0.0, {}, {}, {}, + {}}; + const auto view = p.prepared.view(); + p.separable = objective.separable(i, view); + p.join = join.propose(i, view, state); + p.range = range.propose(i, view); + p.gain = p.separable - separable[i] + p.join.gain + p.range.gain; + if (knn && compressed) { + p.move = knn->move(i, view, state); + p.gain += knn->propose(p.move); + } else if (knn) { + // One trade at a time, so the distances themselves go in parallel + p.distances = knn->distances(i, view, true); + p.gain += knn->propose(i, p.distances); + } + return p; + }; + auto commit = [&](Pending &p) { + const auto i = p.i; + join.apply(p.join); + range.apply(p.range); + if (knn && compressed) + knn->apply(p.move); + else if (knn) + knn->apply(i, p.distances); + owned[i] = std::move(p.prepared); + state[i] = owned[i].view(); + kept[i] = std::move(p.kept); + separable[i] = p.separable; + }; + + struct Offer { + double gain = -std::numeric_limits::infinity(); + std::vector kept; + }; + const std::size_t watch = kKnnWatchFactor * objective.workloads().k; + const auto start_kept = kept; + const double start_value = objective.total(kept); + double value = start_value; + std::cout << std::format("teacher: trading from J_T {:.6f}\n", value); + // Built once: the trades keep it current + if (ranking) + knn.emplace(objective, kept, std::span{}, watch); + for (std::size_t round = 1; round <= kMaxTradeRounds; ++round) { + auto start = std::chrono::steady_clock::now(); + // buy[d][i], sell[d][i]: i's best exact change at b_i + delta and b_i - delta + std::array, kTradeSteps.size()> buy, sell; + for (std::size_t d = 0; d < kTradeSteps.size(); ++d) { + buy[d].resize(n); + sell[d].resize(n); + } + core::parallel_for(n, [&](std::size_t i) { + const std::size_t b = kept[i].size(); + const std::size_t top = std::min(caps[i], db.trajectory(i).size()); + CandidateMaker maker(objective, i, caps[i], true); + auto best_at = [&](std::size_t budget) { + Offer best; + std::vector> seen; + for (std::size_t c = 0; c < kCandidates.size(); ++c) { + auto candidate = maker.make(c, budget); + if (std::ranges::find(seen, candidate) != seen.end()) + continue; + seen.push_back(candidate); + const PreparedTrajectory prepared(db.trajectory(i), candidate); + const auto view = prepared.view(); + double gain = objective.separable(i, view) - separable[i] + + join.propose(i, view, state).gain + range.propose(i, view).gain; + if (knn && compressed) + gain += knn->propose(knn->move(i, view, state)); + else if (knn) + gain += knn->propose_bounded(i, view); + if (gain > best.gain) + best = {gain, std::move(candidate)}; + } + return best; + }; + for (std::size_t d = 0; d < kTradeSteps.size(); ++d) { + if (b + kTradeSteps[d] <= top) + buy[d][i] = best_at(b + kTradeSteps[d]); + if (b >= 2 + kTradeSteps[d]) + sell[d][i] = best_at(b - kTradeSteps[d]); + } + }); + const double sweep_s = core::seconds_since(start); + start = std::chrono::steady_clock::now(); + double knn_correction = 0.0; + // The trades below try only these states, so the kNN lists watch them + if (ranking && !compressed) { + std::vector> prepared(n); + std::vector> versions(n); + core::parallel_for(n, [&](std::size_t i) { + for (const auto *offers : {&buy, &sell}) + for (const auto &by_trajectory : *offers) + if (std::isfinite(by_trajectory[i].gain)) + prepared[i].emplace_back(db.trajectory(i), by_trajectory[i].kept); + for (const auto &version : prepared[i]) + versions[i].push_back(version.view()); + }); + knn->watch(versions, state); + } else if (ranking) { + std::vector offered; + for (const auto *offers : {&buy, &sell}) + for (const auto &by_trajectory : *offers) { + auto &with = offered.emplace_back(kept); + for (std::size_t i = 0; i < n; ++i) + if (std::isfinite(by_trajectory[i].gain)) + with[i] = by_trajectory[i].kept; + } + // The rebuilt lists see what the old ones missed; carry the correction into the total + const double before_rebuild = knn->metric(); + knn.emplace(objective, kept, offered, watch); + knn_correction = objective.scale(Objective::Knn) * (knn->metric() - before_rebuild); + value += knn_correction; + } + const double watch_s = core::seconds_since(start); + start = std::chrono::steady_clock::now(); + + std::vector used(n, 0); + std::size_t profitable = 0, accepted = 0; + const double before = value; + for (std::size_t d = 0; d < kTradeSteps.size(); ++d) { + std::vector> buyers, sellers; + for (std::size_t i = 0; i < n; ++i) { + if (std::isfinite(buy[d][i].gain)) + buyers.push_back({buy[d][i].gain, i}); + if (std::isfinite(sell[d][i].gain)) + sellers.push_back({sell[d][i].gain, i}); + } + std::ranges::sort(buyers, std::greater{}); + std::ranges::sort(sellers, std::greater{}); + std::size_t s = 0; + for (const auto &[buy_gain, r] : buyers) { + if (used[r]) + continue; + while (s < sellers.size() && (used[sellers[s].second] || sellers[s].second == r)) + ++s; + if (s == sellers.size() || buy_gain + sellers[s].first <= kMinImprovement) + break; + const auto seller = sellers[s++].second; + used[r] = used[seller] = 1; + ++profitable; + // Exact: the seller first, then the buyer against the changed state + auto old_kept = kept[seller]; + auto first = pending(seller, std::move(sell[d][seller].kept)); + commit(first); + auto second = pending(r, std::move(buy[d][r].kept)); + if (first.gain + second.gain > kMinImprovement) { + commit(second); + value += first.gain + second.gain; + ++accepted; + } else { + auto back = pending(seller, std::move(old_kept)); + commit(back); + } + } + } + std::cout << std::format( + "teacher: trade round {}: {} profitable pairs, {} kept, J_T {:.6f} " + "-> {:.6f}, kNN rebuild correction {:+.6f}, sweep {:.1f} s, watch {:.1f} s, trades " + "{:.1f} s\n", + round, profitable, accepted, before, value, knn_correction, sweep_s, watch_s, + core::seconds_since(start)); + if (accepted == 0) + break; + } + const auto terms = objective.metrics(kept); + double exact = 0; + for (std::size_t m = 0; m < Objective::TermCount; ++m) + exact += + objective.scale(static_cast(m)) * (terms[m] - objective.floors()[m]); + // Where-at is rescored on every commit, so only these three can drift + std::cout << std::format( + "teacher: trading J_T tracked {:.6f}, exact {:.6f}; tracked/exact kNN {:.6f}/{:.6f}, " + "range {:.6f}/{:.6f}, join {:.6f}/{:.6f}\n", + value, exact, knn ? knn->metric() : terms[Objective::Knn], terms[Objective::Knn], + range.metric(), terms[Objective::Range], join.metric(), terms[Objective::Join]); + // The kNN tracker is not exact everywhere, so the trades could in principle lose + if (exact < start_value) + return {start_kept, start_value}; + return {std::move(kept), exact}; +} + // The workloads with trajectories relabelled among those sharing 1 km start and end cells, in // every join pair and kNN neighbour list: wrong but plausible partners TeacherWorkloads shuffled_partners(const core::TrajectoryDb &db, const TeacherWorkloads &workloads, @@ -551,10 +781,11 @@ std::vector Teacher::run(std::size_t total_budget, std::span Teacher::run(std::size_t total_budget, std::span search; - if (want_loop || want_reallocate || want_no_update) + if (want_loop || want_reallocate || want_trade || want_no_update) search.emplace(db, objective, candidates, choice); - if (want_loop || want_reallocate) { + if (want_loop || want_reallocate || want_trade) { const auto looped = search->run(m_seed); timed("BUDGET_LOOP"); if (want_loop) keep("BUDGET_LOOP", candidates, looped); + if (want_trade) { + auto traded = trade_budgets(db, objective, caps, assemble(candidates, looped)); + outputs["BUDGET_LOOP_TRADE"] = {"BUDGET_LOOP_TRADE", + core::to_simplification(traded.kept), traded.value}; + timed("BUDGET_LOOP_TRADE"); + } if (want_reallocate) { // Each round is kept only if J_T rises auto current = assemble(candidates, looped); diff --git a/engine/tests/teacher/teacher_test.cpp b/engine/tests/teacher/teacher_test.cpp index 1493f1f..49d06d8 100644 --- a/engine/tests/teacher/teacher_test.cpp +++ b/engine/tests/teacher/teacher_test.cpp @@ -16,6 +16,7 @@ #include #include #include +#include #include #include #include @@ -745,44 +746,157 @@ TEST_F(TeacherTest, PreparedIndependentScoresMatchFullScoringAndSurvivePruning) TEST_F(TeacherTest, ArmsKeepTheBudgetAndBestResponseOnlyImproves) { const auto db = random_db(3, 30, 25); - for (const auto mode : {query::JoinMode::Self, query::JoinMode::HeldOut}) { - SCOPED_TRACE(mode == query::JoinMode::Self ? "Self" : "HeldOut"); - auto workloads = teacher::load_or_build_workloads(db, small_config(), 11, m_dir); - const teacher::Teacher model(db, std::move(workloads), {.join_mode = mode}, 11); - const std::vector arms(teacher::kArms.begin(), teacher::kArms.end()); - const std::size_t budget = 2 * db.size() + 40; - const auto result = model.run(budget, arms); + for (const auto mode : {query::JoinMode::Self, query::JoinMode::HeldOut}) + for (const bool ranking : {false, true}) { + SCOPED_TRACE(std::string(mode == query::JoinMode::Self ? "Self" : "HeldOut") + + (ranking ? ", ranking kNN" : "")); + auto workloads = teacher::load_or_build_workloads(db, small_config(), 11, m_dir); + const teacher::Teacher model( + db, std::move(workloads), + {.join_mode = mode, + .ranking_knn = ranking, + .compressed_knn_query = ranking && mode == query::JoinMode::Self}, + 11); + const std::vector arms(teacher::kArms.begin(), teacher::kArms.end()); + const std::size_t budget = 2 * db.size() + 40; + const auto result = model.run(budget, arms); - ASSERT_EQ(result.size(), arms.size()); - double rdp_partners_jt = 0, equal_loop_jt = 0, budget_choice_jt = 0, budget_loop_jt = 0, - reallocate_jt = 0; - for (const auto &arm : result) { - SCOPED_TRACE(arm.name); - ASSERT_EQ(arm.simplification.size(), db.size()); - EXPECT_EQ(arm.simplification.num_points(), budget); - for (std::size_t i = 0; i < db.size(); ++i) { - const auto kept = arm.simplification.trajectory(i); - ASSERT_GE(kept.size(), 2u); - EXPECT_EQ(kept.front(), 0u); - EXPECT_EQ(kept.back(), db.trajectory(i).size() - 1); - EXPECT_TRUE(std::ranges::is_sorted(kept)); - EXPECT_EQ(std::ranges::adjacent_find(kept), kept.end()); + ASSERT_EQ(result.size(), arms.size()); + double rdp_partners_jt = 0, equal_loop_jt = 0, budget_choice_jt = 0, budget_loop_jt = 0, + reallocate_jt = 0, trade_jt = 0; + for (const auto &arm : result) { + SCOPED_TRACE(arm.name); + ASSERT_EQ(arm.simplification.size(), db.size()); + EXPECT_EQ(arm.simplification.num_points(), budget); + for (std::size_t i = 0; i < db.size(); ++i) { + const auto kept = arm.simplification.trajectory(i); + ASSERT_GE(kept.size(), 2u); + EXPECT_EQ(kept.front(), 0u); + EXPECT_EQ(kept.back(), db.trajectory(i).size() - 1); + EXPECT_TRUE(std::ranges::is_sorted(kept)); + EXPECT_EQ(std::ranges::adjacent_find(kept), kept.end()); + } + if (arm.name == "EQUAL_CHOICE_RDP_PARTNERS") + rdp_partners_jt = arm.objective; + if (arm.name == "EQUAL_LOOP") + equal_loop_jt = arm.objective; + if (arm.name == "BUDGET_CHOICE") + budget_choice_jt = arm.objective; + if (arm.name == "BUDGET_LOOP") + budget_loop_jt = arm.objective; + if (arm.name == "BUDGET_LOOP_REALLOCATE") + reallocate_jt = arm.objective; + if (arm.name == "BUDGET_LOOP_TRADE") + trade_jt = arm.objective; } - if (arm.name == "EQUAL_CHOICE_RDP_PARTNERS") - rdp_partners_jt = arm.objective; - if (arm.name == "EQUAL_LOOP") - equal_loop_jt = arm.objective; - if (arm.name == "BUDGET_CHOICE") - budget_choice_jt = arm.objective; - if (arm.name == "BUDGET_LOOP") - budget_loop_jt = arm.objective; - if (arm.name == "BUDGET_LOOP_REALLOCATE") - reallocate_jt = arm.objective; + EXPECT_GE(equal_loop_jt, rdp_partners_jt - 1e-12); + EXPECT_GE(budget_loop_jt, budget_choice_jt - 1e-12); + EXPECT_GE(reallocate_jt, budget_loop_jt - 1e-12); + EXPECT_GE(trade_jt, budget_loop_jt - 1e-12); } - EXPECT_GE(equal_loop_jt, rdp_partners_jt - 1e-12); - EXPECT_GE(budget_loop_jt, budget_choice_jt - 1e-12); - EXPECT_GE(reallocate_jt, budget_loop_jt - 1e-12); +} + +// Each trajectory of random_db twice, the copy shift metres north +core::TrajectoryDb near_duplicates(std::uint64_t seed, std::size_t count, std::size_t length, + double shift = 1e-4) { + const auto source = random_db(seed, count, length); + std::vector offsets{0}; + std::vector ids; + std::vector t; + std::vector lat, lon; + for (std::size_t copy = 0; copy < 2; ++copy) + for (std::size_t i = 0; i < source.size(); ++i) { + const auto trajectory = source.trajectory(i); + ids.push_back(static_cast(ids.size())); + for (std::size_t k = 0; k < trajectory.size(); ++k) { + const auto ll = core::to_lat_lon( + trajectory.x[k], trajectory.y[k] + shift * static_cast(copy)); + t.push_back(trajectory.t[k]); + lat.push_back(ll.lat); + lon.push_back(ll.lon); + } + offsets.push_back(t.size()); + } + return {std::move(offsets), std::move(ids), std::move(t), std::move(lat), std::move(lon)}; +} + +TEST_F(TeacherTest, BoundedKnnProposalsMatchFullDistances) { + const auto db = near_duplicates(5, 24, 20); + auto config = small_config(); + config.extra_join_eps_m.clear(); + config.k = 2; + const auto workloads = teacher::load_or_build_workloads(db, config, 3, m_dir); + const teacher::Objective objective(db, workloads, {.ranking_knn = true}); + std::mt19937_64 rng(8); + auto random_kept = [&](std::size_t i) { + const std::size_t n = db.trajectory(i).size(); + std::vector kept{0}; + for (std::size_t k = 1; k + 1 < n; ++k) + if (rng() % 3 == 0) + kept.push_back(k); + kept.push_back(n - 1); + return kept; + }; + for (const bool start_full : {true, false}) { + teacher::KeptSets state = start_full ? every_point(db) : teacher::KeptSets(db.size()); + if (!start_full) + for (std::size_t i = 0; i < db.size(); ++i) + state[i] = random_kept(i); + const teacher::KnnState knn(objective, state, {}, db.size()); + std::size_t changed = 0; + for (std::size_t i = 0; i < db.size(); ++i) + for (int trial = 0; trial < 8; ++trial) { + const teacher::PreparedTrajectory candidate(db.trajectory(i), random_kept(i)); + const double full = knn.propose(i, knn.distances(i, candidate.view())); + EXPECT_DOUBLE_EQ(knn.propose_bounded(i, candidate.view()), full) << i; + changed += full != 0.0; + } + EXPECT_GT(changed, 0u); + } +} + +TEST_F(TeacherTest, WatchingVersionsMakesKnnProposalsExact) { + // Copies 20 m apart: a copy with all points sits next to its twin, inside queries' top k + const auto db = near_duplicates(6, 24, 20, 20.0); + auto config = small_config(); + config.extra_join_eps_m.clear(); + const auto workloads = teacher::load_or_build_workloads(db, config, 3, m_dir); + const teacher::Objective objective(db, workloads, {.ranking_knn = true}); + std::mt19937_64 rng(9); + auto random_kept = [&](std::size_t i, std::size_t every) { + const std::size_t n = db.trajectory(i).size(); + std::vector kept{0}; + for (std::size_t k = 1; k + 1 < n; ++k) + if (rng() % every == 0) + kept.push_back(k); + kept.push_back(n - 1); + return kept; + }; + teacher::KeptSets state(db.size()); + for (std::size_t i = 0; i < db.size(); ++i) + state[i] = random_kept(i, 1000); + const teacher::PreparedTrajectories prepared(db, state); + const auto views = prepared.views(); + const double before = objective.knn_recall(core::materialize(db, state)); + const double scale = objective.scale(teacher::Objective::Knn); + std::size_t changed = 0; + for (std::size_t i = 0; i < db.size(); ++i) { + // One spare place for whoever replaces a leaver, so versions entering a top k are the only + // ones unwatched until watch() + teacher::KnnState knn(objective, state, {}, workloads.k + 1); + const auto kept = random_kept(i, 1); + const teacher::PreparedTrajectory version(db.trajectory(i), kept); + std::vector> versions(db.size()); + versions[i] = {version.view()}; + knn.watch(versions, views); + auto next = state; + next[i] = kept; + const double exact = scale * (objective.knn_recall(core::materialize(db, next)) - before); + EXPECT_NEAR(knn.propose(i, knn.distances(i, version.view())), exact, 1e-12) << i; + EXPECT_NEAR(knn.propose_bounded(i, version.view()), exact, 1e-12) << i; + changed += exact != 0.0; } + EXPECT_GT(changed, 0u); } TEST_F(TeacherTest, GreedyKeepsTheBudgetAndTheSeed) { From ee1fa18d3f8e379286a10cec5b3c639240ced2c2 Mon Sep 17 00:00:00 2001 From: Kristofferjoha Date: Fri, 20 Nov 2026 13:47:11 +0100 Subject: [PATCH 2/4] scoring consistency --- README.md | 4 + TEACHER_NEXT_STEPS.md | 4 +- engine/include/backend/engine/query/knn.hpp | 17 +- engine/src/query/knn.cpp | 176 +++++++++----------- engine/src/teacher/README.md | 18 +- engine/src/teacher/objective.cpp | 23 ++- engine/src/teacher/workloads.cpp | 8 +- engine/tests/continuous_frechet_test.cpp | 61 +++++++ engine/tests/teacher/teacher_test.cpp | 66 +++++++- 9 files changed, 253 insertions(+), 124 deletions(-) diff --git a/README.md b/README.md index 9175b76..8edf0b9 100644 --- a/README.md +++ b/README.md @@ -89,6 +89,10 @@ and it then falls back to its default. [engine/configs/geolife.json](engine/conf segment with the largest perpendicular error anywhere in the database. It uses no query workloads and receives exactly the same total point budget as the teacher. +Continuous kNN uses the same fixed millimetre-grid ranking in the evaluator and teacher tracker, +with ties resolved by database index. Teacher workload caches from earlier ranking versions are +rebuilt automatically. Recompute older kNN/J4 results when comparing runs across this change. + The teacher's range term uses macro F1 like J4. The loop tracks box coverage counts exactly; independent choices and value curves use F1 marginal gains against fixed partners. diff --git a/TEACHER_NEXT_STEPS.md b/TEACHER_NEXT_STEPS.md index 631f4e6..6bcba7d 100644 --- a/TEACHER_NEXT_STEPS.md +++ b/TEACHER_NEXT_STEPS.md @@ -4,7 +4,9 @@ Implementation update, 2026-11-20: the range objective and endpoint floor now us J4, with exact incremental updates in the loop and F1 marginals for candidate and budget scoring. `RDP_GLOBAL`, a database-wide top-down PED baseline, runs alongside the other baselines in `teacher_eval` and is enabled in `geolife.json`. It is included in the best-cheap-baseline comparison. -The numerical findings below predate this change and need to be checked with fresh runs. +Continuous kNN now shares a deterministic millimetre-grid ranking between the evaluator and +tracker; V6 caches rebuild old reference rankings. Limited watch lists remain approximate. +The numerical findings below predate these changes and need to be checked with fresh runs. Updated 2026-11-17 on branch `teacher`. The teacher is described in [engine/src/teacher/README.md](engine/src/teacher/README.md); this file says what is settled and diff --git a/engine/include/backend/engine/query/knn.hpp b/engine/include/backend/engine/query/knn.hpp index 05bec03..3d7bb2e 100644 --- a/engine/include/backend/engine/query/knn.hpp +++ b/engine/include/backend/engine/query/knn.hpp @@ -9,6 +9,19 @@ namespace query { +inline constexpr double kKnnResolutionM = 1e-3; + +// Continuous distances are rounded up to a fixed millimetre grid using the decision predicate. +// The grid makes ranking independent of the search bounds, candidate order and requested k. +// Discrete distances are unchanged. Use this distance for cached kNN rankings too. +double knn_distance(const core::TrajectoryView &a, const core::TrajectoryView &b, + FrechetVariant variant = FrechetVariant::Continuous); + +inline bool knn_rank_less(double distance_a, std::size_t index_a, double distance_b, + std::size_t index_b) { + return distance_a < distance_b || (distance_a == distance_b && index_a < index_b); +} + struct KnnQuery { std::size_t query_index; // index into KnnWorkload::queries std::vector reference; // knn in the uncompressed database, closest first @@ -39,8 +52,8 @@ KnnWorkload generate_knn_queries(const core::TrajectoryDb &original, std::uint64_t seed = 42); // Indices into trajectories of the k trajectories closest to query by Fréchet distance, closest -// first. Equal distances are ordered by database index; continuous distances within 1 mm count -// as equal. +// first, using knn_distance and knn_rank_less. Continuous distances in the same millimetre bin +// are tied by database index; discrete distance ties also use the database index. std::vector knn(const core::TrajectoryDb &trajectories, const core::TrajectoryView &query, std::size_t k, FrechetVariant variant = FrechetVariant::Continuous); diff --git a/engine/src/query/knn.cpp b/engine/src/query/knn.cpp index eea8bb9..992cd38 100644 --- a/engine/src/query/knn.cpp +++ b/engine/src/query/knn.cpp @@ -229,92 +229,56 @@ std::vector discrete_knn(const core::TrajectoryDb &trajectory_db, return neighbor_ids; } -// A candidate whose continuous distance is known to lie in [lo, hi] -struct Bracket { +// The first millimetre radius accepted by the continuous decision predicate. Unlike an +// arbitrary bisection midpoint, this key is identical for different valid initial bounds. +double continuous_rank_distance(const core::TrajectoryView &a, const core::TrajectoryView &b, + double lower, double upper) { + if (!std::isfinite(upper)) + return std::numeric_limits::infinity(); + // Geometric lower bounds and the decision predicate have rounding slack. Start below it, + // so an accepted grid point is never skipped just because a bound rounded upward. + const double slack = 2e-12 * std::max(1.0, lower); + const double first = std::ceil(std::max(0.0, lower - slack) / kKnnResolutionM); + const double last = std::ceil(upper / kKnnResolutionM); + if (last >= static_cast(std::numeric_limits::max())) + throw std::overflow_error("knn: distance exceeds millimetre ranking range"); + auto lo = static_cast(first); + auto hi = static_cast(last); + // Most distances equal their Hausdorff bound. Resolve those with one decision instead of + // bisecting the entire interval up to the discrete upper bound. + if (lo < hi && continuous_frechet_within(a, b, static_cast(lo) * kKnnResolutionM)) + return static_cast(lo) * kKnnResolutionM; + if (lo < hi) + ++lo; + while (lo < hi) { + const auto mid = lo + (hi - lo) / 2; + if (continuous_frechet_within(a, b, static_cast(mid) * kKnnResolutionM)) + hi = mid; + else + lo = mid + 1; + } + return static_cast(lo) * kKnnResolutionM; +} + +struct RankedNeighbor { + double distance; std::size_t idx; - double lo; - double hi; + bool operator<(const RankedNeighbor &other) const { + return knn_rank_less(distance, idx, other.distance, other.idx); + } }; -// Each distance is narrowed only as far as top-k membership and order need. Distances within -// tolerance of each other count as equal and are ordered by database index, and the same rule -// decides membership at the k-th place. Every prune allows the tolerance as well. std::vector continuous_knn(const core::TrajectoryDb &trajectory_db, const core::TrajectoryView &query, std::size_t k) { - constexpr double tolerance = 1e-3; CandidateQueue queue(trajectory_db, query, k); - std::vector kept; - std::vector scratch; - const auto halve = [&](Bracket &b) { - const double mid = 0.5 * (b.lo + b.hi); - if (continuous_frechet_within(query, trajectory_db.trajectory(b.idx), mid)) - b.hi = mid; - else - b.lo = mid; - }; - const auto kth_upper = [&] { - scratch.clear(); - for (const auto &b : kept) - scratch.push_back(b.hi); - std::nth_element(scratch.begin(), scratch.begin() + static_cast(k - 1), - scratch.end()); - return scratch[k - 1]; - }; - // Narrows overlapping brackets until they are disjoint or within tolerance, then orders runs - // of overlapping brackets, which are ties, by index - const auto rank = [&] { - const auto by_lower = [](const Bracket &b) { return std::pair(b.lo, b.idx); }; - for (bool overlapping = true; overlapping;) { - overlapping = false; - std::ranges::sort(kept, {}, by_lower); - for (std::size_t i = 0; i + 1 < kept.size(); ++i) { - Bracket &a = kept[i], &b = kept[i + 1]; - if (a.hi < b.lo) - continue; - Bracket &wider = a.hi - a.lo >= b.hi - b.lo ? a : b; - if (wider.hi - wider.lo <= tolerance) - continue; - halve(wider); - overlapping = true; - } - } - for (std::size_t start = 0; start < kept.size();) { - std::size_t end = start + 1; - double reach = kept[start].hi; - while (end < kept.size() && kept[end].lo <= reach) - reach = std::max(reach, kept[end++].hi); - std::ranges::sort(kept.begin() + static_cast(start), - kept.begin() + static_cast(end), {}, &Bracket::idx); - start = end; - } - }; - // Drops brackets that are certainly beyond the k-th, refining the widest uncertain one. - // Once only ties remain at the boundary, the ranking decides who stays. - const auto trim = [&] { - while (kept.size() > k) { - const double cutoff = kth_upper(); - std::erase_if(kept, [&](const Bracket &b) { return b.lo > cutoff + tolerance; }); - if (kept.size() <= k) - return; - Bracket *widest = nullptr; - for (auto &b : kept) - if (b.hi >= cutoff && b.hi - b.lo > tolerance && - (!widest || b.hi - b.lo > widest->hi - widest->lo)) - widest = &b; - if (!widest) { - rank(); - kept.resize(k); - return; - } - halve(*widest); - } - }; - + std::priority_queue nearest; std::vector prev, curr; while (!queue.empty()) { const Candidate candidate = queue.next(); - const double cutoff = kept.size() < k ? std::sqrt(queue.initial_cutoff()) : kth_upper(); - const double limit = cutoff + tolerance; + // One extra bin absorbs floating-point rounding in bounds and includes all distance ties. + const double limit = + (nearest.size() < k ? std::sqrt(queue.initial_cutoff()) : nearest.top().distance) + + kKnnResolutionM; const double squared_limit = limit * limit; if (candidate.squared_lower_bound > squared_limit) break; @@ -328,36 +292,50 @@ std::vector continuous_knn(const core::TrajectoryDb &trajectory_db, std::max(forward, squared_directed_hausdorff(reference, query, squared_limit)); if (squared_hausdorff > squared_limit) continue; - // The discrete distance bounds the continuous one from above - double hi = limit; - const double squared_discrete = get_squared_frechet_distance( - query, reference, std::nextafter(squared_limit, squared_limit + 1.0), prev, curr); - if (squared_discrete <= squared_limit) - hi = std::min(hi, std::sqrt(squared_discrete)); + double upper = limit; + const double discrete = get_squared_frechet_distance( + query, reference, + std::nextafter(squared_limit, std::numeric_limits::infinity()), prev, curr); + if (discrete <= squared_limit) + upper = std::min(upper, std::sqrt(discrete)); else if (!continuous_frechet_within(query, reference, limit)) continue; - double lo = std::min( - hi, std::max(std::sqrt(candidate.squared_lower_bound), std::sqrt(squared_hausdorff))); - // The distance often equals the Hausdorff bound - if (hi - lo > tolerance) { - if (continuous_frechet_within(query, reference, lo + tolerance)) - hi = lo + tolerance; - else - lo += tolerance; + const double lower = + std::min(upper, std::sqrt(std::max(candidate.squared_lower_bound, squared_hausdorff))); + const RankedNeighbor next{continuous_rank_distance(query, reference, lower, upper), + candidate.idx}; + if (!std::isfinite(next.distance)) + continue; + if (nearest.size() < k) + nearest.push(next); + else if (next < nearest.top()) { + nearest.pop(); + nearest.push(next); } - kept.push_back({candidate.idx, lo, hi}); - trim(); } - - rank(); - std::vector neighbor_ids; - for (const auto &b : kept) - neighbor_ids.push_back(b.idx); - return neighbor_ids; + std::vector result(nearest.size()); + for (std::size_t i = result.size(); i > 0; --i) { + result[i - 1] = nearest.top().idx; + nearest.pop(); + } + return result; } } // namespace +double knn_distance(const core::TrajectoryView &a, const core::TrajectoryView &b, + FrechetVariant variant) { + const double upper = frechet_distance(a, b); + if (variant == FrechetVariant::Discrete || !std::isfinite(upper)) + return upper; + const double squared_upper = upper * upper; + const double lower = std::sqrt( + std::max({squared_endpoint_lower_bound(a, b), squared_box_extent_lower_bound(a, b), + squared_directed_hausdorff(a, b, squared_upper), + squared_directed_hausdorff(b, a, squared_upper)})); + return continuous_rank_distance(a, b, std::min(lower, upper), upper); +} + std::vector knn(const core::TrajectoryDb &trajectory_db, const core::TrajectoryView &query_trajectory, std::size_t k, FrechetVariant variant) { diff --git a/engine/src/teacher/README.md b/engine/src/teacher/README.md index 6ee0ecf..4898ea0 100644 --- a/engine/src/teacher/README.md +++ b/engine/src/teacher/README.md @@ -12,6 +12,13 @@ Range scoring changed on 2026-11-20: J_T now uses macro F1, including its endpoi matching J4. Historical teacher selections and J_T values need a fresh run. `RDP_GLOBAL` is the query-independent database-wide top-down PED baseline in both experiment runners. +Continuous kNN now uses one numerical ranking in both the evaluator and `KnnState`: the +smallest millimetre-grid radius accepted by the Fréchet decision predicate, with equal keys +ordered by database index. This replaces evaluator-specific overlapping intervals and the +tracker's independently bisected scalar distances. Rankings near ties can change; V6 caches +rebuild the reference neighbours, and earlier kNN/J4 results should be rerun. Generic Fréchet +distances and join decisions are unchanged. Limited kNN watch lists remain an approximation. + ## How it fits together ``` @@ -326,8 +333,8 @@ not. They matter because the join metric is F1: simplification can make negative - **Computation:** in parallel, for each trajectory e: 1. find its k+2 nearest neighbours (`query::knn`) and remove e itself; 2. keep the first k as `top`; - 3. compute `cutoff`, the distance to the (k+1)th neighbour, with `query::frechet_distance`. For continuous - Fréchet, the discrete distance is used as the upper bound of the search. + 3. compute `cutoff`, the distance to the (k+1)th neighbour, with `query::frechet_distance`. This cutoff remains a proxy used by value curves. Ranking kNN + uses `query::knn_distance`, shared with the evaluator. - **Output:** one `KnnEntry` per trajectory. ### `collect_pairs(db, eps_m, frechet, positives, negatives)` — internal @@ -343,8 +350,9 @@ not. They matter because the join metric is F1: simplification can make negative ### `save` / `load` / `write_pairs` / `read_pairs` / `put` / `get` — internal - **Why:** the cache file format. -- **Version 5** (read and written): a header (magic number, seed, full-content fingerprint, k, - eps, variant), then the kNN entries, positives and negatives. Version 4 also stored a seen / +- **Version 6** (read and written): a header (magic number, seed, full-content fingerprint, k, + eps, variant), then the kNN entries, positives and negatives. Version 5 has the same layout + but an obsolete continuous-kNN ranking policy, so it is rebuilt. Version 4 also stored a seen / unseen flag per pair and is rejected. The version covers both file layout and cached workload generation and must be bumped when either changes. - **Versions 2 and 3** are rejected because they used metadata-only fingerprints. @@ -731,6 +739,8 @@ These timings predate the seven-candidate teacher, allocation search and cache c real change in J_T. - `SeveralJoinTermsAreTrackedExactly`: the same exactness with two extra thresholds, with and without the held-out term. +- `ContinuousKnnNearTiesMatchFullScoringThroughSwitches`: the former 23/24 versus 1 regression, + checked through original/compressed query switches and bounded proposals. - `RankingKnnIsTrackedExactly`: when every query watches every trajectory, `KnnState`'s tracked recall equals a full recompute after random switches, and the kNN, range, join and separable changes together predict the real change in J_T. diff --git a/engine/src/teacher/objective.cpp b/engine/src/teacher/objective.cpp index 2e34552..ca6ce62 100644 --- a/engine/src/teacher/objective.cpp +++ b/engine/src/teacher/objective.cpp @@ -72,8 +72,8 @@ double range_marginal(std::size_t others, std::size_t expected, std::size_t scor } constexpr std::size_t kMaxJoinTerms = 8; -// query::frechet_distance's continuous search tolerance -constexpr double kKnnDistanceError = 1e-3; +// Cached kNN distances are upper bounds on a fixed millimetre grid. +constexpr double kKnnDistanceError = query::kKnnResolutionM; double f1_of(std::size_t hits, std::size_t found, std::size_t expected) { return 2.0 * static_cast(hits) / static_cast(found + expected); @@ -761,8 +761,8 @@ std::vector KnnState::distances(std::size_t i, const core::TrajectoryVie const auto &watchers = m_watchers[i]; std::vector result(watchers.size()); auto one = [&](std::size_t s) { - result[s] = query::frechet_distance(db.trajectory(watchers[s].query), candidate, - m_objective.workloads().frechet); + result[s] = query::knn_distance(db.trajectory(watchers[s].query), candidate, + m_objective.workloads().frechet); }; if (parallel) core::parallel_for(watchers.size(), one); @@ -781,7 +781,7 @@ std::vector KnnState::own_row(std::size_t e, const core::TrajectoryView std::vector row; row.reserve(m_list[e].size()); for (const auto j : m_list[e]) - row.push_back(query::frechet_distance(query, state[j], m_objective.workloads().frechet)); + row.push_back(query::knn_distance(query, state[j], m_objective.workloads().frechet)); return row; } @@ -792,8 +792,8 @@ KnnState::Move KnnState::move(std::size_t i, const core::TrajectoryView &candida Move result{i, {}, own_row(i, candidate, state)}; result.watched.reserve(m_watchers[i].size()); for (const auto &watcher : m_watchers[i]) - result.watched.push_back(query::frechet_distance(state[watcher.query], candidate, - m_objective.workloads().frechet)); + result.watched.push_back( + query::knn_distance(state[watcher.query], candidate, m_objective.workloads().frechet)); return result; } @@ -844,7 +844,7 @@ std::size_t KnnState::ranked_hits(std::size_t e, // Ties go to the lower database index, like query::knn std::ranges::partial_sort( order, order.begin() + static_cast(k), [&](const auto &a, const auto &b) { - return a.first < b.first || (a.first == b.first && list[a.second] < list[b.second]); + return query::knn_rank_less(a.first, list[a.second], b.first, list[b.second]); }); std::size_t count = 0; for (std::size_t p = 0; p < k; ++p) @@ -882,9 +882,8 @@ void KnnState::watch(std::span> versions continue; for (const auto &version : versions[i]) if (query::frechet_within(db.trajectory(e), version, radius[e], frechet)) { - added[i].push_back( - {static_cast(e), - query::frechet_distance(db.trajectory(e), state[i], frechet)}); + added[i].push_back({static_cast(e), + query::knn_distance(db.trajectory(e), state[i], frechet)}); break; } } @@ -935,7 +934,7 @@ double KnnState::propose_bounded(std::size_t i, const core::TrajectoryView &cand else if (!query::frechet_within(query, candidate, *kth + margin, frechet)) now = outside; else - now = hits(e, position, query::frechet_distance(query, candidate, frechet)); + now = hits(e, position, query::knn_distance(query, candidate, frechet)); } change += static_cast(now) - static_cast(m_hits[e]); } diff --git a/engine/src/teacher/workloads.cpp b/engine/src/teacher/workloads.cpp index e3b47c7..a468940 100644 --- a/engine/src/teacher/workloads.cpp +++ b/engine/src/teacher/workloads.cpp @@ -18,8 +18,8 @@ namespace teacher { namespace { -// Bump when the layout or workload generation changes. V5 drops the seen / unseen split -constexpr std::uint64_t kMagicV5 = 0x5431'4341'4348'4535ull; +// Bump when the layout or workload generation changes. V6 uses fixed-grid continuous kNN. +constexpr std::uint64_t kMagicV6 = 0x5431'4341'4348'4536ull; constexpr std::uint64_t kFnvOffsetBasis = 14695981039346656037ull; constexpr std::uint64_t kFnvPrime = 1099511628211ull; @@ -119,7 +119,7 @@ void save(const std::filesystem::path &file, std::uint64_t seed, std::uint64_t d const auto tmp = file.string() + ".tmp"; { std::ofstream out(tmp, std::ios::binary); - put(out, kMagicV5); + put(out, kMagicV6); put(out, seed); put(out, db_fingerprint); put(out, workloads.k); @@ -145,7 +145,7 @@ bool load(const std::filesystem::path &file, std::uint64_t seed, std::uint64_t d std::ifstream in(file, std::ios::binary); if (!in) return false; - if (get(in) != kMagicV5 || get(in) != seed || + if (get(in) != kMagicV6 || get(in) != seed || get(in) != db_fingerprint) return false; const auto k = get(in); diff --git a/engine/tests/continuous_frechet_test.cpp b/engine/tests/continuous_frechet_test.cpp index be38c64..585fc2f 100644 --- a/engine/tests/continuous_frechet_test.cpp +++ b/engine/tests/continuous_frechet_test.cpp @@ -242,6 +242,67 @@ struct RawLine { core::TrajectoryView view() const { return {0, t, {}, {}, x, y}; } }; +TEST(ContinuousFrechet, KnnDistanceUsesTheSameGridUnderDifferentSampling) { + const RawLine line({{0, 0}, {10, 0}}); + const RawLine subdivided({{0, 0}, {3, 0}, {7, 0}, {10, 0}}); + for (const double x : {8.0, 8.001, 8.0015}) { + const RawLine backtrack({{0, 0}, {x, 0}, {2, 0}, {10, 0}}); + const double key = query::knn_distance(line.view(), backtrack.view()); + EXPECT_DOUBLE_EQ(key, query::knn_distance(subdivided.view(), backtrack.view())); + EXPECT_DOUBLE_EQ(key, query::knn_distance(backtrack.view(), line.view())); + EXPECT_TRUE(query::continuous_frechet_within(line.view(), backtrack.view(), key)); + EXPECT_FALSE(query::continuous_frechet_within(line.view(), backtrack.view(), + key - query::kKnnResolutionM)); + } + const RawLine a({{0, 0}, {8.001, 0}, {2, 0}, {10, 0}}); + const RawLine b({{0, 0}, {8.0015, 0}, {2, 0}, {10, 0}}); + EXPECT_DOUBLE_EQ(query::knn_distance(line.view(), a.view()), + query::knn_distance(line.view(), b.view())); + EXPECT_DOUBLE_EQ(query::knn_distance(line.view(), a.view(), query::FrechetVariant::Discrete), + query::frechet_distance(line.view(), a.view())); +} + +TEST(ContinuousFrechet, KnnNearTiePrefixesMatchIndependentCachedDistancesForEveryK) { + const auto database = make_db({{{0, 0}, {8.001, 0}, {2, 0}, {10, 0}}, + {{0, 0}, {8.0015, 0}, {2, 0}, {10, 0}}, + {{0, 0}, {8, 0}, {2, 0}, {10, 0}}, + {{0, 0}, {3, 0}, {7, 0}, {10, 0}}, + {{0, 10}, {10, 10}}, + {{0, 0}, {5, 20}, {10, 0}}}); + for (std::size_t q = 0; q < database.size(); ++q) { + const auto query = database.trajectory(q); + std::vector> reference; + for (std::size_t i = 0; i < database.size(); ++i) + reference.push_back({query::knn_distance(query, database.trajectory(i)), i}); + std::ranges::sort(reference); + for (std::size_t k = 1; k <= database.size() + 1; ++k) { + std::vector expected; + for (std::size_t i = 0; i < std::min(k, reference.size()); ++i) + expected.push_back(reference[i].second); + EXPECT_EQ(query::knn(database, query, k), expected) << "q=" << q << ", k=" << k; + } + } +} + +TEST(ContinuousFrechet, KnnMatchesCachedRankingOnRandomWalks) { + std::mt19937_64 rng(267); + const auto database = make_db(random_lines(rng, 32, 12)); + const auto queries = make_db(random_lines(rng, 12, 10)); + for (std::size_t q = 0; q < queries.size(); ++q) { + const auto trajectory = queries.trajectory(q); + std::vector> reference; + for (std::size_t i = 0; i < database.size(); ++i) + reference.push_back({query::knn_distance(trajectory, database.trajectory(i)), i}); + std::ranges::sort(reference); + for (const std::size_t k : {1u, 2u, 5u, 10u, 32u, 40u}) { + std::vector expected; + for (std::size_t i = 0; i < std::min(k, reference.size()); ++i) + expected.push_back(reference[i].second); + EXPECT_EQ(query::knn(database, trajectory, k), expected) << "q=" << q << ", k=" << k; + } + } +} + TEST(ContinuousFrechet, LongSegmentWithAVertexOnItIsAtDistanceZeroExactCoordinates) { const double bx = -81677.87045, by = -85151.97823; for (const double f : {0.75641311848, 0.5, 0.1, 0.999, 0.333333333}) { diff --git a/engine/tests/teacher/teacher_test.cpp b/engine/tests/teacher/teacher_test.cpp index 49d06d8..640eb24 100644 --- a/engine/tests/teacher/teacher_test.cpp +++ b/engine/tests/teacher/teacher_test.cpp @@ -185,14 +185,15 @@ TEST_F(TeacherTest, CacheWithLegacyFingerprintIsRebuilt) { const auto file = m_dir / "teacher_cache_seed5.bin"; const auto current = read_cache(file); ASSERT_FALSE(current.empty()); - for (const std::uint64_t legacy : {0x5431'4341'4348'4532ull, 0x5431'4341'4348'4533ull}) { + for (const std::uint64_t legacy : + {0x5431'4341'4348'4532ull, 0x5431'4341'4348'4533ull, 0x5431'4341'4348'4535ull}) { SCOPED_TRACE(legacy); { std::fstream out(file, std::ios::binary | std::ios::in | std::ios::out); out.write(reinterpret_cast(&legacy), sizeof(legacy)); ASSERT_TRUE(out); } - // An obsolete version is rejected even when everything else matches + // Reject obsolete fingerprints and V5's adaptive continuous-kNN reference ordering ASSERT_NE(read_cache(file), current); const auto rebuilt = teacher::load_or_build_workloads(db, small_config(), 5, m_dir); EXPECT_EQ(read_cache(file), current); @@ -562,6 +563,67 @@ TEST_F(TeacherTest, CompressedKnnQueriesNeedTheRankingTerm) { std::invalid_argument); } +TEST_F(TeacherTest, ContinuousKnnNearTiesMatchFullScoringThroughSwitches) { + // The first trajectory is a line; the next two backtrack by almost the same amount. + // The old evaluator tied overlapping distance intervals, while the tracker sorted their + // independently approximated distances: even the full database scored 23/24 instead of 1. + const auto source = random_db(2, 24, 20); + const std::array line{0.0, 3.0, 7.0, 10.0}, loop{0.0, 8.0, 2.0, 10.0}; + std::vector offsets{0}; + std::vector ids; + std::vector times; + std::vector lat, lon; + for (std::size_t i = 0; i < source.size(); ++i) { + ids.push_back(static_cast(i)); + const auto original = source.trajectory(i); + for (std::size_t k = 0; k < (i < 3 ? line.size() : original.size()); ++k) { + const double x = i >= 3 ? original.x[k] + : i == 0 ? line[k] + : loop[k] + (i == 1 && k == 1 ? 0.001 : 0.0); + const auto point = core::to_lat_lon(x, i < 3 ? 0.0 : original.y[k]); + times.push_back(static_cast(k)); + lat.push_back(point.lat); + lon.push_back(point.lon); + } + offsets.push_back(times.size()); + } + const core::TrajectoryDb db(offsets, ids, times, lat, lon); + auto config = small_config(); + config.k = 1; + config.join_eps_m = 2.0; + const auto workloads = teacher::load_or_build_workloads(db, config, 99, m_dir); + const auto full = every_point(db), floor = endpoints(db); + const teacher::PreparedTrajectories prepared_full(db, full), prepared_floor(db, floor); + const auto full_views = prepared_full.views(), floor_views = prepared_floor.views(); + for (const bool compressed : {false, true}) { + SCOPED_TRACE(compressed ? "compressed queries" : "original queries"); + const teacher::Objective objective(db, workloads, + {.join_mode = query::JoinMode::HeldOut, + .ranking_knn = true, + .compressed_knn_query = compressed}); + auto kept = full; + auto views = full_views; + teacher::KnnState knn(objective, kept, {}, db.size()); + EXPECT_DOUBLE_EQ(objective.knn_recall(core::materialize(db, kept)), 1.0); + EXPECT_DOUBLE_EQ(knn.metric(), 1.0); + for (const auto i : {1u, 2u, 0u, 5u, 1u, 0u, 2u, 5u}) { + const bool shrink = kept[i].size() != 2; + const auto candidate = shrink ? floor_views[i] : full_views[i]; + const double before = objective.knn_recall(core::materialize(db, kept)); + const auto move = knn.move(i, candidate, views); + const double gain = knn.propose(move); + if (!compressed) + EXPECT_NEAR(knn.propose_bounded(i, candidate), gain, 1e-12); + kept[i] = shrink ? floor[i] : full[i]; + views[i] = candidate; + knn.apply(move); + const double after = objective.knn_recall(core::materialize(db, kept)); + EXPECT_NEAR(knn.metric(), after, 1e-12); + EXPECT_NEAR(gain, objective.scale(teacher::Objective::Knn) * (after - before), 1e-12); + } + } +} + TEST_F(TeacherTest, CompressedKnnArmsKeepTheBudgetAndLoopOnlyImproves) { const auto db = random_db(3, 30, 25); auto workloads = teacher::load_or_build_workloads(db, small_config(), 11, m_dir); From 61cce4d091b002b66ef944e2f2b87191711a3dcf Mon Sep 17 00:00:00 2001 From: Kristofferjoha Date: Fri, 20 Nov 2026 13:57:06 +0100 Subject: [PATCH 3/4] seller --- .../backend/engine/teacher/trade_matching.hpp | 25 ++++++++++++++ engine/src/teacher/teacher.cpp | 11 ++++--- engine/tests/teacher/teacher_test.cpp | 33 +++++++++++++++++++ 3 files changed, 64 insertions(+), 5 deletions(-) create mode 100644 engine/include/backend/engine/teacher/trade_matching.hpp diff --git a/engine/include/backend/engine/teacher/trade_matching.hpp b/engine/include/backend/engine/teacher/trade_matching.hpp new file mode 100644 index 0000000..a336a2f --- /dev/null +++ b/engine/include/backend/engine/teacher/trade_matching.hpp @@ -0,0 +1,25 @@ +#pragma once + +#include +#include +#include + +namespace teacher::detail { + +// Sellers are sorted by descending gain. Only used sellers can permanently advance first; +// a seller excluded for being this buyer remains available to subsequent buyers. +inline std::size_t find_profitable_seller(std::span> sellers, + std::span used, std::size_t &first, + std::size_t buyer, double buy_gain, double min_gain) { + while (first < sellers.size() && used[sellers[first].second]) + ++first; + auto candidate = first; + while (candidate < sellers.size() && + (used[sellers[candidate].second] || sellers[candidate].second == buyer)) + ++candidate; + if (candidate == sellers.size() || buy_gain + sellers[candidate].first <= min_gain) + return sellers.size(); + return candidate; +} + +} // namespace teacher::detail diff --git a/engine/src/teacher/teacher.cpp b/engine/src/teacher/teacher.cpp index 3937ce8..d9299e5 100644 --- a/engine/src/teacher/teacher.cpp +++ b/engine/src/teacher/teacher.cpp @@ -8,6 +8,7 @@ #include "backend/engine/selection/selector.hpp" #include "backend/engine/teacher/curves.hpp" #include "backend/engine/teacher/greedy.hpp" +#include "backend/engine/teacher/trade_matching.hpp" #include #include @@ -617,11 +618,11 @@ Traded trade_budgets(const core::TrajectoryDb &db, const Objective &objective, for (const auto &[buy_gain, r] : buyers) { if (used[r]) continue; - while (s < sellers.size() && (used[sellers[s].second] || sellers[s].second == r)) - ++s; - if (s == sellers.size() || buy_gain + sellers[s].first <= kMinImprovement) - break; - const auto seller = sellers[s++].second; + const auto match = + detail::find_profitable_seller(sellers, used, s, r, buy_gain, kMinImprovement); + if (match == sellers.size()) + continue; + const auto seller = sellers[match].second; used[r] = used[seller] = 1; ++profitable; // Exact: the seller first, then the buyer against the changed state diff --git a/engine/tests/teacher/teacher_test.cpp b/engine/tests/teacher/teacher_test.cpp index 640eb24..50a5b97 100644 --- a/engine/tests/teacher/teacher_test.cpp +++ b/engine/tests/teacher/teacher_test.cpp @@ -6,6 +6,7 @@ #include "backend/engine/teacher/greedy.hpp" #include "backend/engine/teacher/objective.hpp" #include "backend/engine/teacher/teacher.hpp" +#include "backend/engine/teacher/trade_matching.hpp" #include "backend/engine/teacher/workloads.hpp" #include @@ -858,6 +859,38 @@ TEST_F(TeacherTest, ArmsKeepTheBudgetAndBestResponseOnlyImproves) { } } +TEST(TradeMatching, SelfSellerRemainsAvailableAfterAnUnprofitableBuyer) { + // Buyer 0 cannot sell to itself, and seller 2 is too expensive. Buyer 1 can still profitably + // buy from seller 0; neither skipping seller 0 nor ending the buyer sweep is valid. + const std::vector> sellers{{0.0, 0}, {-20.0, 2}}; + const std::vector used(3, 0); + std::size_t first = 0; + EXPECT_EQ(teacher::detail::find_profitable_seller(sellers, used, first, 0, 10.0, 1e-12), + sellers.size()); + EXPECT_EQ(first, 0u); + EXPECT_EQ(teacher::detail::find_profitable_seller(sellers, used, first, 1, 9.0, 1e-12), 0u); + + // The same applies when the buyer itself is the only remaining seller. + const auto only = std::span(sellers).first(1); + EXPECT_EQ(teacher::detail::find_profitable_seller(only, used, first, 0, 10.0, 1e-12), + only.size()); + EXPECT_EQ(teacher::detail::find_profitable_seller(only, used, first, 1, 9.0, 1e-12), 0u); +} + +TEST(TradeMatching, AdvancesOnlyPastUsedSellers) { + const std::vector> sellers{{3.0, 0}, {2.0, 1}, {1.0, 2}}; + std::vector used{1, 0, 0}; + std::size_t first = 0; + EXPECT_EQ(teacher::detail::find_profitable_seller(sellers, used, first, 1, 1.0, 1e-12), 2u); + EXPECT_EQ(first, 1u); + used[2] = 1; + EXPECT_EQ(teacher::detail::find_profitable_seller(sellers, used, first, 0, 1.0, 1e-12), 1u); + used[1] = 1; + EXPECT_EQ(teacher::detail::find_profitable_seller(sellers, used, first, 0, 1.0, 1e-12), + sellers.size()); + EXPECT_EQ(first, sellers.size()); +} + // Each trajectory of random_db twice, the copy shift metres north core::TrajectoryDb near_duplicates(std::uint64_t seed, std::size_t count, std::size_t length, double shift = 1e-4) { From 135c2a53cc3b5f6f563d2661fe4c680e9d1fba17 Mon Sep 17 00:00:00 2001 From: TB-PC Date: Fri, 20 Nov 2026 16:37:37 +0100 Subject: [PATCH 4/4] Carry kNN watch-list metric change into tracked J_T before trading Widening the kNN watch lists before trading can change the tracked kNN metric of the current state; add that difference to the tracked total so trade acceptance compares against the right baseline. --- engine/src/teacher/teacher.cpp | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/engine/src/teacher/teacher.cpp b/engine/src/teacher/teacher.cpp index d9299e5..83bfee6 100644 --- a/engine/src/teacher/teacher.cpp +++ b/engine/src/teacher/teacher.cpp @@ -569,8 +569,10 @@ Traded trade_budgets(const core::TrajectoryDb &db, const Objective &objective, }); const double sweep_s = core::seconds_since(start); start = std::chrono::steady_clock::now(); - double knn_correction = 0.0; - // The trades below try only these states, so the kNN lists watch them + // The trades below try only these states, so the kNN lists watch them. Either way the + // lists can now see trajectories the old ones missed, which changes the tracked metric + // of the current state; that change is carried into the tracked total below + const double before_watch = ranking ? knn->metric() : 0.0; if (ranking && !compressed) { std::vector> prepared(n); std::vector> versions(n); @@ -592,12 +594,11 @@ Traded trade_budgets(const core::TrajectoryDb &db, const Objective &objective, if (std::isfinite(by_trajectory[i].gain)) with[i] = by_trajectory[i].kept; } - // The rebuilt lists see what the old ones missed; carry the correction into the total - const double before_rebuild = knn->metric(); knn.emplace(objective, kept, offered, watch); - knn_correction = objective.scale(Objective::Knn) * (knn->metric() - before_rebuild); - value += knn_correction; } + const double knn_correction = + ranking ? objective.scale(Objective::Knn) * (knn->metric() - before_watch) : 0.0; + value += knn_correction; const double watch_s = core::seconds_since(start); start = std::chrono::steady_clock::now(); @@ -642,7 +643,7 @@ Traded trade_budgets(const core::TrajectoryDb &db, const Objective &objective, } std::cout << std::format( "teacher: trade round {}: {} profitable pairs, {} kept, J_T {:.6f} " - "-> {:.6f}, kNN rebuild correction {:+.6f}, sweep {:.1f} s, watch {:.1f} s, trades " + "-> {:.6f}, kNN list correction {:+.6f}, sweep {:.1f} s, watch {:.1f} s, trades " "{:.1f} s\n", round, profitable, accepted, before, value, knn_correction, sweep_s, watch_s, core::seconds_since(start));