feat(ml): 纵向 LR 接 PSI 行对齐
影响:两方各持不同客户名单时,能先 PSI 求交再密态训练纵向 LR; 此前 demo 隐含「行已对齐」,真实业务走不通。 - `nax_psi::align_by_key`:从测试上提为公开函数(PSI 结果的后处理), 按共享键字节序排序;键重复即报错(一对多 join 不支持)。 - `run_lr_vertical_session`:两方各持不同客户、不同特征列的完整纵向 LR, PSI → align → 0 分片拼接列块。列块排布在碰网络前就校验。 - 新增 `tests/lr_vertical_psi.rs`(4 测):含变异检验——去掉排序后 2 条红。
This commit is contained in:
1 parent
c97da57c5f
commit
355d1be699
3 files changed
+569
No files matched your search
@@ -672,6 +672,228 @@ pub fn run_lr_session<T: Transport>(
|
||||
Ok(w)
|
||||
}
|
||||
|
||||
/// 真实纵向 LR 的配置:两方各持**不同客户**、**不同特征列**。
|
||||
///
|
||||
/// 与 [`LrConfig`] 的区别:那个假设两方行已对齐、列形状相同(demo 用,
|
||||
/// 两方传同一份数据即可);这个从 PSI 开始 —— 行由求交决定,列由公开 schema 定位。
|
||||
pub struct VerticalLrConfig {
|
||||
/// 本方 site 名。
|
||||
pub site: String,
|
||||
/// 全体参与方(含本方)。目前只支持两方。
|
||||
pub sites: Vec<String>,
|
||||
/// 密态会话主种子(派生 Beaver 物料,**两方必须一致**)。
|
||||
pub seed: [u8; 32],
|
||||
/// 定点小数位。
|
||||
pub fxp: u32,
|
||||
/// 本方的 join 键(PSI 输入,长度 = 本方样本数)。
|
||||
pub ids: Vec<Vec<u8>>,
|
||||
/// PSI 会话种子。两方**必须不同** —— 同种子等于双方私钥相同,
|
||||
/// ECDH 退化成共享标量,测不出真实的交换律。
|
||||
pub psi_seed: [u8; 32],
|
||||
/// 本方特征,行主序 `n_own × d_own`。
|
||||
pub x: Vec<f64>,
|
||||
/// 本方贡献的列数。
|
||||
pub d_own: usize,
|
||||
/// 本方列在**全局列序**里的起点(公开 schema)。
|
||||
pub col_offset: usize,
|
||||
/// 全局总列数(两方必须一致,等于两方 `d_own` 之和)。
|
||||
pub d_total: usize,
|
||||
/// 本方标签(长度 `n_own`);本方不持标签时留空,由对端提供。
|
||||
pub y: Vec<f64>,
|
||||
/// 训练轮数。
|
||||
pub epochs: usize,
|
||||
/// 学习率。
|
||||
pub lr: f64,
|
||||
}
|
||||
|
||||
/// 跑一次**真纵向** LR:先 PSI 求交、再按共享键对齐、再密态训练。
|
||||
///
|
||||
/// # 两条连接
|
||||
///
|
||||
/// PSI 与密态会话必须走**两条独立连接**。混用同一条会让帧串到对端的
|
||||
/// `recv` 上 —— `PsiPoints` 与 `Shares` 的 op 不同,直接报协议错。
|
||||
///
|
||||
/// # 列怎么拼成一行
|
||||
///
|
||||
/// 两方各持自己的列块,在自己**不持有的列位置填 0 分片**,加和恰好
|
||||
/// 等于列拼接 —— 因为两方的分片各自只在自己的列位置非零。
|
||||
/// 所以 `VerticalLR::fit` 不用改:它看到的 `x_sh` 加和就是
|
||||
/// `n × d_total` 的完整特征矩阵。
|
||||
///
|
||||
/// # 返回
|
||||
///
|
||||
/// `(对齐后的本方行下标, 权重)`。行下标是**本方原始行序**,
|
||||
/// 调用方可用它核对两方是否对齐到了同一批样本。
|
||||
pub fn run_lr_vertical_session<T: Transport>(
|
||||
psi_transport: T,
|
||||
vault_transport: T,
|
||||
cfg: &VerticalLrConfig,
|
||||
verbose: bool,
|
||||
) -> Result<(Vec<usize>, Vec<u64>), NodeError> {
|
||||
use nax_ml::VerticalLR;
|
||||
|
||||
if cfg.sites.len() != 2 {
|
||||
return Err(NodeError::Session(format!(
|
||||
"纵向 LR 目前只支持两方,得到 {} 方",
|
||||
cfg.sites.len()
|
||||
)));
|
||||
}
|
||||
if cfg.x.len() != cfg.ids.len() * cfg.d_own {
|
||||
return Err(NodeError::Session(format!(
|
||||
"特征长度 {} ≠ 样本数 {} × 本方列数 {}",
|
||||
cfg.x.len(),
|
||||
cfg.ids.len(),
|
||||
cfg.d_own
|
||||
)));
|
||||
}
|
||||
if !cfg.y.is_empty() && cfg.y.len() != cfg.ids.len() {
|
||||
return Err(NodeError::Session(format!(
|
||||
"标签长度 {} ≠ 样本数 {}",
|
||||
cfg.y.len(),
|
||||
cfg.ids.len()
|
||||
)));
|
||||
}
|
||||
if cfg.col_offset + cfg.d_own > cfg.d_total {
|
||||
return Err(NodeError::Session(format!(
|
||||
"本方列块 [{}, {}) 超出总列数 {}",
|
||||
cfg.col_offset,
|
||||
cfg.col_offset + cfg.d_own,
|
||||
cfg.d_total
|
||||
)));
|
||||
}
|
||||
|
||||
// 列块排布在**碰网络之前**就要定下来:两方场景只有两种合法排布
|
||||
// (本方在前 / 本方在后)。悬空的列块会让拼出来的矩阵静默错位,
|
||||
// 所以宁可在这里拒绝,也不要等到 PSI 跑完才发现。
|
||||
let d_peer = cfg.d_total - cfg.d_own;
|
||||
let peer_off = if cfg.col_offset == 0 {
|
||||
cfg.d_own
|
||||
} else if cfg.col_offset == d_peer {
|
||||
0
|
||||
} else {
|
||||
return Err(NodeError::Session(format!(
|
||||
"列块 [{}, {})、总列数 {} —— 只支持两方列块首尾相接(col_offset 必须为 0 或 {})",
|
||||
cfg.col_offset,
|
||||
cfg.col_offset + cfg.d_own,
|
||||
cfg.d_total,
|
||||
d_peer
|
||||
)));
|
||||
};
|
||||
|
||||
// 1) PSI:本方交集下标(本地行序升序)
|
||||
let psi_cfg = PsiConfig {
|
||||
site: cfg.site.clone(),
|
||||
sites: cfg.sites.clone(),
|
||||
ids: cfg.ids.clone(),
|
||||
seed: cfg.psi_seed,
|
||||
};
|
||||
let hits = run_psi_session(psi_transport, &psi_cfg, verbose)?;
|
||||
log(verbose, &format!("PSI 交集 {} 条", hits.len()));
|
||||
|
||||
// 2) 按共享规范键排序 —— 两方得到同一个顺序
|
||||
let order = nax_psi::align_by_key(&cfg.ids, &hits).map_err(NodeError::Session)?;
|
||||
let n = order.len();
|
||||
log(verbose, &format!("对齐后 {n} 行"));
|
||||
|
||||
// 3) 只留交集行,并按对齐行序重排本方特征
|
||||
let mut x_aligned = Vec::with_capacity(n * cfg.d_own);
|
||||
for &row in &order {
|
||||
x_aligned.extend_from_slice(&cfg.x[row * cfg.d_own..(row + 1) * cfg.d_own]);
|
||||
}
|
||||
let x_enc: Vec<u64> = x_aligned
|
||||
.iter()
|
||||
.map(|v| ring::encode(*v, cfg.fxp).map_err(|e| NodeError::Session(e.to_string())))
|
||||
.collect::<Result<_, _>>()?;
|
||||
|
||||
// 4) 分片交换:本方留一片、对端给一片(先全发再全收,避免双向死锁)
|
||||
let site_refs: Vec<&str> = cfg.sites.iter().map(|s| s.as_str()).collect();
|
||||
let mut vault = Vault::new(vault_transport, &cfg.site, &site_refs, cfg.seed, cfg.fxp)?;
|
||||
let peer_idx = 1 - vault.my_index();
|
||||
|
||||
let all_x = vault.split(&x_enc)?;
|
||||
let x_mine = vault.my_slice(&all_x)?.to_vec();
|
||||
vault.send_share(peer_idx, &all_x)?;
|
||||
let x_peer = vault.recv_share()?;
|
||||
|
||||
if x_mine.len() != n * cfg.d_own {
|
||||
return Err(NodeError::Session(format!(
|
||||
"本方分片长度 {} ≠ n×d_own = {}×{}",
|
||||
x_mine.len(),
|
||||
n,
|
||||
cfg.d_own
|
||||
)));
|
||||
}
|
||||
if x_peer.len() != n * d_peer {
|
||||
return Err(NodeError::Session(format!(
|
||||
"对端分片长度 {} ≠ n×d_peer = {}×{} —— 两方对 d_total/d_own 的理解不一致",
|
||||
x_peer.len(),
|
||||
n,
|
||||
d_peer
|
||||
)));
|
||||
}
|
||||
|
||||
// 5) 拼全局列序(`peer_off` / `d_peer` 已在入口定好并校验过)
|
||||
let mut x_sh = vec![0u64; n * cfg.d_total];
|
||||
for i in 0..n {
|
||||
for k in 0..cfg.d_own {
|
||||
x_sh[i * cfg.d_total + cfg.col_offset + k] = x_mine[i * cfg.d_own + k];
|
||||
}
|
||||
// 对端列块:加和即拼接(本方在这些位置是 0)
|
||||
for k in 0..d_peer {
|
||||
let slot = &mut x_sh[i * cfg.d_total + peer_off + k];
|
||||
*slot = slot.wrapping_add(x_peer[i * d_peer + k]);
|
||||
}
|
||||
}
|
||||
log(
|
||||
verbose,
|
||||
&format!("特征拼接完成 ({n} 行 × {} 列)", cfg.d_total),
|
||||
);
|
||||
|
||||
// 6) 标签:只有一方提供,另一方按全零分片参与(全零 split 后加和为 0)
|
||||
let y_enc: Vec<u64> = if cfg.y.is_empty() {
|
||||
vec![0u64; n]
|
||||
} else {
|
||||
let mut out = Vec::with_capacity(n);
|
||||
for &row in &order {
|
||||
out.push(
|
||||
ring::encode(cfg.y[row], cfg.fxp)
|
||||
.map_err(|e| NodeError::Session(e.to_string()))?,
|
||||
);
|
||||
}
|
||||
out
|
||||
};
|
||||
let all_y = vault.split(&y_enc)?;
|
||||
let y_mine = vault.my_slice(&all_y)?.to_vec();
|
||||
vault.send_share(peer_idx, &all_y)?;
|
||||
let y_peer = vault.recv_share()?;
|
||||
let y_sh: Vec<u64> = y_mine
|
||||
.iter()
|
||||
.zip(y_peer.iter())
|
||||
.map(|(a, b)| a.wrapping_add(*b))
|
||||
.collect();
|
||||
log(verbose, "y 分片交换完成");
|
||||
|
||||
// 7) 训练(d 传全局列数,两方一致)
|
||||
let model = VerticalLR {
|
||||
lr: cfg.lr,
|
||||
epochs: cfg.epochs,
|
||||
l2: 0.0,
|
||||
sigmoid_degree: 7,
|
||||
fit_intercept: true,
|
||||
};
|
||||
log(
|
||||
verbose,
|
||||
&format!("开始训练 ({} 轮, lr={}, d_total={})", cfg.epochs, cfg.lr, cfg.d_total),
|
||||
);
|
||||
let w_sh = model
|
||||
.fit(&mut vault, &x_sh, n, cfg.d_total, &y_sh)
|
||||
.map_err(|e| NodeError::Session(e.to_string()))?;
|
||||
|
||||
let w = vault.reveal(&w_sh)?;
|
||||
log(verbose, "训练完成");
|
||||
Ok((order, w))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
@@ -0,0 +1,311 @@
|
||||
//! 真纵向 LR 端到端:两方各持**不同客户**、**不同特征列**。
|
||||
//!
|
||||
//! ```text
|
||||
//! PSI(本方交集下标,本地行序)
|
||||
//! → nax_psi::align_by_key(按共享键字节序重排,两方同一顺序)
|
||||
//! → 各在自己不持有的列位置填 0 分片 → 加和即列拼接
|
||||
//! → VerticalLR::fit(密态)→ reveal → 对拍明文
|
||||
//! ```
|
||||
//!
|
||||
//! # 这条测试要守什么
|
||||
//!
|
||||
//! 既有的 `nax lr` demo 要求两方传**同一份**数据(`LrConfig` 里 `d` 是
|
||||
//! "每人贡献的列数",加和后仍是 d 列)。真实纵向场景是反过来的:
|
||||
//! 客户名单只部分重叠,特征各持一半。这条测试覆盖后者 ——
|
||||
//! alice 只有 `balance`,bob 只有 `spend`/`region`,交集 7 人,
|
||||
//! 训练出的 4 个权重(3 列 + 偏置)必须与明文 LR 高度一致。
|
||||
//!
|
||||
//! # 为什么数据要标准化到 ±1
|
||||
//!
|
||||
//! 密态 sigmoid 是 7 次奇多项式,只在拟合区间 `|z| ≤ R = 6` 内有效。
|
||||
//! 原始量纲(余额几百、消费几十)会让 `z = X·w` 立刻冲出区间,
|
||||
//! 训练必然发散 —— 那是数值问题,不是协议问题,不该混进这条测试。
|
||||
|
||||
use std::thread;
|
||||
|
||||
use nax_core::ring;
|
||||
use nax_ml::plaintext_lr;
|
||||
use nax_node::{run_lr_vertical_session, VerticalLrConfig};
|
||||
use nax_psi::id_from_u64;
|
||||
use nax_vault::Pipe;
|
||||
|
||||
const FXP: u32 = 18;
|
||||
const SITES: [&str; 2] = ["alice", "bob"];
|
||||
|
||||
/// 一方:自己的客户名单 + 自己的特征列 + 可能的标签。
|
||||
#[derive(Clone)]
|
||||
struct Party {
|
||||
site: &'static str,
|
||||
/// PSI 会话种子。两方**故意不同** —— 同种子等于双方私钥相同。
|
||||
psi_seed: [u8; 32],
|
||||
ids: Vec<u64>,
|
||||
/// 每列一个 Vec,长度都等于 `ids.len()`。
|
||||
cols: Vec<Vec<f64>>,
|
||||
y: Vec<f64>,
|
||||
}
|
||||
|
||||
impl Party {
|
||||
fn keys(&self) -> Vec<Vec<u8>> {
|
||||
self.ids.iter().map(|v| id_from_u64(*v)).collect()
|
||||
}
|
||||
|
||||
fn d_own(&self) -> usize {
|
||||
self.cols.len()
|
||||
}
|
||||
|
||||
/// 行主序平铺。
|
||||
fn x_flat(&self) -> Vec<f64> {
|
||||
let n = self.ids.len();
|
||||
let mut out = Vec::with_capacity(n * self.cols.len());
|
||||
for i in 0..n {
|
||||
for c in &self.cols {
|
||||
out.push(c[i]);
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// 数据:alice 持 (id, balance),bob 持 (uid, spend, region, y)
|
||||
//
|
||||
// alice ids: 7 2 4 1 8 3 9 5
|
||||
// bob ids: 4 9 2 3 5 1 6 8
|
||||
// 交集 = {1,2,3,4,5,8,9},7 条(key 6 只有 bob 有,key 7 只有 alice 有)
|
||||
//
|
||||
// 两方本地行序**互不相同**,且交集在两侧的位置序列不同:
|
||||
// alice 交集位置 = [3,1,5,2,7,4,6]
|
||||
// bob 交集位置 = [5,2,3,0,4,7,1]
|
||||
// 不排序直接拼列 = 行错位,结果不崩但数不对。
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
fn sample() -> (Party, Party) {
|
||||
// 按 key 1,2,3,4,5,8,9 的明文取值见 `plaintext_expected()`。
|
||||
// 这里按**各自本地行序**填,所以下面的数组看起来"乱"——那是故意的。
|
||||
|
||||
// alice 行序 7,2,4,1,8,3,9,5 → key 7 不在交集,填 0
|
||||
let alice = Party {
|
||||
site: "alice",
|
||||
psi_seed: [0x11; 32],
|
||||
ids: vec![7, 2, 4, 1, 8, 3, 9, 5],
|
||||
// key: 7 2 4 1 8 3 9 5
|
||||
cols: vec![vec![0.0, -0.75, -0.25, -1.0, 0.75, -0.5, 1.0, 0.0]],
|
||||
y: vec![],
|
||||
};
|
||||
|
||||
// bob 行序 4,9,2,3,5,1,6,8 → key 6 不在交集(填 0)
|
||||
let bob = Party {
|
||||
site: "bob",
|
||||
psi_seed: [0x22; 32],
|
||||
ids: vec![4, 9, 2, 3, 5, 1, 6, 8],
|
||||
cols: vec![
|
||||
// 4 9 2 3 5 1 6 8
|
||||
vec![-0.25, 1.0, -0.75, -0.5, 0.0, -1.0, 0.0, 0.75], // spend
|
||||
vec![0.5, 0.5, 0.0, 0.0, 0.5, 0.0, 0.0, 0.5], // region
|
||||
],
|
||||
y: vec![1.0, 1.0, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0],
|
||||
};
|
||||
(alice, bob)
|
||||
}
|
||||
|
||||
/// 对齐后(key 1,2,3,4,5,8,9)的明文特征矩阵与标签,用于对照。
|
||||
fn plaintext_expected() -> (Vec<f64>, Vec<f64>) {
|
||||
// key: 1 2 3 4 5 8 9
|
||||
let x = vec![
|
||||
-1.0, -1.0, 0.0, // key 1
|
||||
-0.75, -0.75, 0.0, // key 2
|
||||
-0.5, -0.5, 0.0, // key 3
|
||||
-0.25, -0.25, 0.5, // key 4
|
||||
0.0, 0.0, 0.5, // key 5
|
||||
0.75, 0.75, 0.5, // key 8
|
||||
1.0, 1.0, 0.5, // key 9
|
||||
];
|
||||
let y = vec![0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0];
|
||||
(x, y)
|
||||
}
|
||||
|
||||
fn cfg_of(p: &Party, col_offset: usize, d_total: usize) -> VerticalLrConfig {
|
||||
VerticalLrConfig {
|
||||
site: p.site.to_string(),
|
||||
sites: SITES.iter().map(|s| s.to_string()).collect(),
|
||||
seed: [0x5Bu8; 32], // 密态主种子:两方必须一致
|
||||
fxp: FXP,
|
||||
ids: p.keys(),
|
||||
psi_seed: p.psi_seed,
|
||||
x: p.x_flat(),
|
||||
d_own: p.d_own(),
|
||||
col_offset,
|
||||
d_total,
|
||||
y: p.y.clone(),
|
||||
// lr 必须温和:sigmoid 是 7 次多项式,只在 |z| ≤ R = 6 内有效。
|
||||
// 步长稍大一点 w 就会过冲,z 冲出区间 → 多项式爆炸 → 不可逆发散。
|
||||
// 这是数值问题,与 PSI / 对齐无关,所以参数要和明文对照取同一组。
|
||||
epochs: 40,
|
||||
lr: 0.3,
|
||||
}
|
||||
}
|
||||
|
||||
/// 一方的会话输出:`(对齐行下标, 权重)`,或失败原因。
|
||||
type PartyOut = Result<(Vec<usize>, Vec<u64>), String>;
|
||||
|
||||
/// 跑两方会话,返回两方各自的结果。
|
||||
fn run_pair(a: &Party, b: &Party) -> (PartyOut, PartyOut) {
|
||||
let d_total = a.d_own() + b.d_own();
|
||||
let (psi_a, psi_b) = Pipe::pair();
|
||||
let (va, vb) = Pipe::pair();
|
||||
|
||||
let ca = cfg_of(a, 0, d_total);
|
||||
let cb = cfg_of(b, a.d_own(), d_total);
|
||||
|
||||
let ha = thread::spawn(move || {
|
||||
run_lr_vertical_session(psi_a, va, &ca, false)
|
||||
.map_err(|e| e.to_string())
|
||||
});
|
||||
let hb = thread::spawn(move || {
|
||||
run_lr_vertical_session(psi_b, vb, &cb, false)
|
||||
.map_err(|e| e.to_string())
|
||||
});
|
||||
(
|
||||
ha.join().expect("alice 线程 panic"),
|
||||
hb.join().expect("bob 线程 panic"),
|
||||
)
|
||||
}
|
||||
|
||||
fn decode_weights(w: &[u64]) -> Vec<f64> {
|
||||
w.iter().map(|&v| ring::decode(v, FXP)).collect()
|
||||
}
|
||||
|
||||
/// 皮尔逊相关系数。密态用 7 次多项式 sigmoid、明文用精确 sigmoid,
|
||||
/// 两者的**收敛目标**一致但不逐位相同,所以按相关性验收(与 README 口径一致)。
|
||||
fn corr(a: &[f64], b: &[f64]) -> f64 {
|
||||
assert_eq!(a.len(), b.len());
|
||||
let n = a.len() as f64;
|
||||
let ma = a.iter().sum::<f64>() / n;
|
||||
let mb = b.iter().sum::<f64>() / n;
|
||||
let (mut cov, mut va, mut vb) = (0.0, 0.0, 0.0);
|
||||
for i in 0..a.len() {
|
||||
let da = a[i] - ma;
|
||||
let db = b[i] - mb;
|
||||
cov += da * db;
|
||||
va += da * da;
|
||||
vb += db * db;
|
||||
}
|
||||
cov / (va.sqrt() * vb.sqrt())
|
||||
}
|
||||
|
||||
/// 端到端:PSI → 对齐 → 列拼接 → 密态训练,权重对拍明文 LR。
|
||||
#[test]
|
||||
fn vertical_lr_over_psi_matches_plaintext() {
|
||||
let (a, b) = sample();
|
||||
let (x_plain, y_plain) = plaintext_expected();
|
||||
|
||||
let (ra, rb) = run_pair(&a, &b);
|
||||
let (oa, wa) = ra.expect("alice 侧失败");
|
||||
let (ob, wb) = rb.expect("bob 侧失败");
|
||||
|
||||
// 两方必须对齐到**同一批样本**:交集 7 条,且权重一致(reveal 后同值)
|
||||
assert_eq!(oa.len(), 7, "交集应为 7 条");
|
||||
assert_eq!(ob.len(), 7, "交集应为 7 条");
|
||||
assert_eq!(wa, wb, "两方 reveal 出的权重必须相同");
|
||||
|
||||
// 对齐后的键序列(用各自的行下标映射回 id)
|
||||
let keys_a: Vec<u64> = oa.iter().map(|&i| a.ids[i]).collect();
|
||||
let keys_b: Vec<u64> = ob.iter().map(|&i| b.ids[i]).collect();
|
||||
assert_eq!(keys_a, keys_b, "两方对齐后的键序列必须逐条相同");
|
||||
assert_eq!(
|
||||
keys_a,
|
||||
vec![1, 2, 3, 4, 5, 8, 9],
|
||||
"规范序 = 键的字节序(1<2<3<4<5<8<9)"
|
||||
);
|
||||
|
||||
// 明文对照:同样的拼接特征、同样的 y(同一组超参)
|
||||
let w_plain = plaintext_lr(&x_plain, &y_plain, 7, 3, 0.3, 40, 0.0, true);
|
||||
let w_enc = decode_weights(&wa);
|
||||
assert_eq!(w_enc.len(), 4, "3 列 + 偏置");
|
||||
|
||||
let r = corr(&w_plain, &w_enc);
|
||||
assert!(
|
||||
r > 0.95,
|
||||
"密态权重与明文 LR 应高度一致,实际 r = {r:.4}\n 明文: {w_plain:?}\n 密态: {w_enc:?}"
|
||||
);
|
||||
|
||||
// balance 与 spend 同向(两组特征取值相同、标签同向),二者权重应同号
|
||||
assert!(
|
||||
w_enc[0] * w_enc[1] > 0.0,
|
||||
"两列特征同向,权重应同号: {w_enc:?}"
|
||||
);
|
||||
}
|
||||
|
||||
/// 列拼接的正确性:若两方错位(不排序),拼出来的特征矩阵会串行。
|
||||
///
|
||||
/// 这条不跑密态,只验证「对齐后两方的行确实指向同一个 key」这个前提 ——
|
||||
/// 它一旦不成立,上面的训练测试就算过了也是巧合。
|
||||
#[test]
|
||||
fn psi_alignment_puts_same_person_on_same_row() {
|
||||
let (a, b) = sample();
|
||||
let (ka, kb) = (a.keys(), b.keys());
|
||||
|
||||
// 明文模拟 PSI 的输出形状(本方交集下标、本地行序升序)。
|
||||
// 注意:交集判定要拿**对端**的键集合去查本方的键,不能拿自己查自己。
|
||||
let mut kb_sorted = kb.clone();
|
||||
kb_sorted.sort();
|
||||
let hits_a: Vec<usize> = (0..ka.len())
|
||||
.filter(|&i| kb_sorted.binary_search(&ka[i]).is_ok())
|
||||
.collect();
|
||||
let mut ka_sorted = ka.clone();
|
||||
ka_sorted.sort();
|
||||
let hits_b: Vec<usize> = (0..kb.len())
|
||||
.filter(|&i| ka_sorted.binary_search(&kb[i]).is_ok())
|
||||
.collect();
|
||||
|
||||
// PSI 返回的是**本地行序升序**的下标,不是按 key 排的
|
||||
assert_eq!(hits_a, vec![1, 2, 3, 4, 5, 6, 7], "alice 交集位置(本地行序)");
|
||||
assert_eq!(hits_b, vec![0, 1, 2, 3, 4, 5, 7], "bob 交集位置(本地行序)");
|
||||
|
||||
let oa = nax_psi::align_by_key(&ka, &hits_a).unwrap();
|
||||
let ob = nax_psi::align_by_key(&kb, &hits_b).unwrap();
|
||||
|
||||
// 对齐后 = 按 key 字节序重排,两方这才拿到同一个顺序
|
||||
assert_eq!(oa, vec![3, 1, 5, 2, 7, 4, 6], "alice 对齐后行序");
|
||||
assert_eq!(ob, vec![5, 2, 3, 0, 4, 7, 1], "bob 对齐后行序");
|
||||
|
||||
let sa: Vec<&Vec<u8>> = oa.iter().map(|&i| &ka[i]).collect();
|
||||
let sb: Vec<&Vec<u8>> = ob.iter().map(|&i| &kb[i]).collect();
|
||||
assert_eq!(sa, sb, "排序后两方键序列必须一致");
|
||||
}
|
||||
|
||||
/// 交集为空:必须在训练前失败,而不是拿空列去跑 MPC。
|
||||
#[test]
|
||||
fn disjoint_parties_fail_before_training() {
|
||||
let a = Party {
|
||||
site: "alice",
|
||||
psi_seed: [0x11; 32],
|
||||
ids: vec![1, 2],
|
||||
cols: vec![vec![1.0, 2.0]],
|
||||
y: vec![],
|
||||
};
|
||||
let b = Party {
|
||||
site: "bob",
|
||||
psi_seed: [0x22; 32],
|
||||
ids: vec![8, 9],
|
||||
cols: vec![vec![3.0, 4.0]],
|
||||
y: vec![0.0, 1.0],
|
||||
};
|
||||
let (ra, rb) = run_pair(&a, &b);
|
||||
// 两侧都该失败(PSI 交集为空 → align_by_key 报错)
|
||||
assert!(ra.is_err(), "alice 侧应在训练前失败");
|
||||
assert!(rb.is_err(), "bob 侧应在训练前失败");
|
||||
}
|
||||
|
||||
/// 配置自检:列块既不贴左也不贴右时报错,而不是拼出一个错的矩阵。
|
||||
#[test]
|
||||
fn misaligned_column_block_is_rejected() {
|
||||
let (a, _) = sample();
|
||||
// d_total=5、d_own=1、col_offset=2 → 中间悬空
|
||||
let cfg = cfg_of(&a, 2, 5);
|
||||
let (psi, _psi_peer) = Pipe::pair();
|
||||
let (v, _v_peer) = Pipe::pair();
|
||||
// 对端缺席无所谓:入口校验在**碰网络之前**就该拒绝
|
||||
let r = run_lr_vertical_session(psi, v, &cfg, false);
|
||||
assert!(r.is_err(), "悬空列块应在开始时被拒绝");
|
||||
}
|
||||
@@ -133,6 +133,42 @@ pub fn resolve(perm: &[usize], positions: &[usize]) -> Vec<usize> {
|
||||
out
|
||||
}
|
||||
|
||||
/// 把「本方落在交集里的行」按**共享规范键**排序,返回按对齐行序排列的行下标。
|
||||
///
|
||||
/// # 为什么必须排序
|
||||
///
|
||||
/// [`resolve`] 返回的是**本地行序**升序的下标 —— 两方拿到的序列互不相同,
|
||||
/// 也不含共享顺序。下游的纵向拼接(同一个人在两方各有一行,拼成一行特征)
|
||||
/// 要求「两方第 i 行是同一个人」,所以两边必须按同一个**全序**重排。
|
||||
/// 这里用键的字节序:任何两方一致的全序都行,关键是别用本地行序。
|
||||
///
|
||||
/// 副作用(已知且接受):排序暴露了本方键相对对端键的秩,与 PSI 本身
|
||||
/// 泄露交集是同一量级的元信息;不排序则结果直接错 —— 不崩、不报错,就是数不对。
|
||||
///
|
||||
/// # 三种失败
|
||||
///
|
||||
/// - **交集为空**:两方没有公共样本。继续往下跑会拿空列去 open,在此明确失败。
|
||||
/// - **下标越界**:协议错乱的信号,不能当成正常情况处理。
|
||||
/// - **本方键重复**:对应一对多 join,纵向对齐(一人一行)表达不了笛卡尔展开,
|
||||
/// 必须在切分片**之前**拒绝,而不是按行号静默错拼。
|
||||
pub fn align_by_key(keys: &[Vec<u8>], hits: &[usize]) -> Result<Vec<usize>, String> {
|
||||
if hits.is_empty() {
|
||||
return Err("交集为空:两方没有可对齐的行".into());
|
||||
}
|
||||
if let Some(&bad) = hits.iter().find(|&&i| i >= keys.len()) {
|
||||
return Err(format!("PSI 交集中出现越界下标 {bad}"));
|
||||
}
|
||||
let mut order = hits.to_vec();
|
||||
order.sort_by(|&x, &y| keys[x].cmp(&keys[y]));
|
||||
if let Some(w) = order.windows(2).find(|w| keys[w[0]] == keys[w[1]]) {
|
||||
return Err(format!(
|
||||
"join 键在本方重复(第 {} 与第 {} 行),一对多 join 不支持",
|
||||
w[0], w[1]
|
||||
));
|
||||
}
|
||||
Ok(order)
|
||||
}
|
||||
|
||||
/// Fisher–Yates 洗牌,随机源用会话 PRG。
|
||||
fn shuffle(v: &mut [usize], s: &mut Stream) {
|
||||
let n = v.len();
|
||||
|
||||
Reference in new issue
Block a user