ci / gate (push) Waiting to run
- 项目与文档标题:nax-rs → ssw-mpc(尚数网-多方安全计算),二进制 nax → mpc - 18 个 crate 及目录 nax-* → mpc-*,Rust 引用 nax_* → mpc_* - 环境变量、C 符号、构建/部署脚本:NAX_* → MPC_*、libnax_ray.so → libmpc_ray.so - 保留协议域分隔常量与 refs/nax 参考实现路径,维持 golden 向量与历史数据兼容 - 新增 [profile.dev] incremental=false
559 lines
21 KiB
Rust
559 lines
21 KiB
Rust
//! 真纵向 LR 端到端:两方各持**不同客户**、**不同特征列**。
|
||
//!
|
||
//! ```text
|
||
//! PSI(本方交集下标,本地行序)
|
||
//! → mpc_psi::align_by_key(按共享键字节序重排,两方同一顺序)
|
||
//! → 各在自己不持有的列位置填 0 分片 → 加和即列拼接
|
||
//! → VerticalLR::fit(密态)→ reveal → 对拍明文
|
||
//! ```
|
||
//!
|
||
//! # 这条测试要守什么
|
||
//!
|
||
//! 既有的 `mpc 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 mpc_core::ring;
|
||
use mpc_ml::plaintext_lr;
|
||
use mpc_node::{run_lr_vertical_session, ColBlock, VerticalLrConfig};
|
||
use mpc_psi::id_from_u64;
|
||
use mpc_vault::{MeshPipe, Pipe};
|
||
|
||
const FXP: u32 = 18;
|
||
|
||
/// 一方:自己的客户名单 + 自己的特征列 + 可能的标签。
|
||
#[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 blocks_of(parties: &[&Party]) -> Vec<ColBlock> {
|
||
let mut out = Vec::new();
|
||
let mut off = 0usize;
|
||
for p in parties {
|
||
out.push(ColBlock::new(p.site, off, p.d_own()));
|
||
off += p.d_own();
|
||
}
|
||
out
|
||
}
|
||
|
||
fn cfg_of(
|
||
p: &Party,
|
||
blocks: Vec<ColBlock>,
|
||
d_total: usize,
|
||
label_owner: &str,
|
||
) -> VerticalLrConfig {
|
||
let mine = blocks
|
||
.iter()
|
||
.find(|b| b.site == p.site)
|
||
.expect("本方列块必须在清单里")
|
||
.clone();
|
||
// 清单与 sites 同序:party 下标就是 blocks 下标
|
||
let sites: Vec<String> = blocks.iter().map(|b| b.site.clone()).collect();
|
||
VerticalLrConfig {
|
||
site: p.site.to_string(),
|
||
sites,
|
||
seed: [0x5Bu8; 32], // 密态主种子:全体必须一致
|
||
fxp: FXP,
|
||
ids: p.keys(),
|
||
psi_seed: p.psi_seed,
|
||
x: p.x_flat(),
|
||
d_own: p.d_own(),
|
||
col_offset: mine.offset,
|
||
d_total,
|
||
blocks,
|
||
label_owner: label_owner.to_string(),
|
||
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 blocks = blocks_of(&[a, b]);
|
||
let d_total: usize = blocks.iter().map(|b| b.len).sum();
|
||
let (psi_a, psi_b) = Pipe::pair();
|
||
let (va, vb) = Pipe::pair();
|
||
|
||
let ca = cfg_of(a, blocks.clone(), d_total, "bob");
|
||
let cb = cfg_of(b, blocks, d_total, "bob");
|
||
|
||
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 = mpc_psi::align_by_key(&ka, &hits_a).unwrap();
|
||
let ob = mpc_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, b) = sample();
|
||
// alice 占 [0,1)、bob 占 [2,4) —— 第 1 列没人写,d_total 却报 5
|
||
let blocks = vec![ColBlock::new("alice", 0, 1), ColBlock::new("bob", 2, 2)];
|
||
let cfg = cfg_of(&a, blocks, 5, "bob");
|
||
let (psi, _psi_peer) = Pipe::pair();
|
||
let (v, _v_peer) = Pipe::pair();
|
||
// 对端缺席无所谓:入口校验在**碰网络之前**就该拒绝
|
||
let r = run_lr_vertical_session(psi, v, &cfg, false);
|
||
let msg = r.expect_err("悬空列块应在开始时被拒绝").to_string();
|
||
assert!(msg.contains("不接续"), "错误要指向列块,实际: {msg}");
|
||
|
||
// 列块铺满但与 d_total 不符
|
||
let blocks = vec![ColBlock::new("alice", 0, 1), ColBlock::new("bob", 1, 2)];
|
||
let cfg = cfg_of(&a, blocks, 5, "bob");
|
||
let (psi, _psi_peer) = Pipe::pair();
|
||
let (v, _v_peer) = Pipe::pair();
|
||
let msg = run_lr_vertical_session(psi, v, &cfg, false)
|
||
.expect_err("铺不满 d_total 应被拒绝")
|
||
.to_string();
|
||
assert!(msg.contains("d_total"), "错误要指向总列数,实际: {msg}");
|
||
let _ = b;
|
||
}
|
||
|
||
/// 非 label_owner 却带了标签必须被拒绝 —— 否则 n 方会把标签累加 n 次。
|
||
#[test]
|
||
fn non_owner_with_label_is_rejected() {
|
||
let (a, b) = sample();
|
||
let blocks = blocks_of(&[&a, &b]);
|
||
let d_total: usize = blocks.iter().map(|x| x.len).sum();
|
||
let mut cfg = cfg_of(&a, blocks, d_total, "bob");
|
||
cfg.y = vec![1.0; cfg.ids.len()]; // alice 不是 owner 却给了 y
|
||
let (psi, _psi_peer) = Pipe::pair();
|
||
let (v, _v_peer) = Pipe::pair();
|
||
let msg = run_lr_vertical_session(psi, v, &cfg, false)
|
||
.expect_err("非 owner 带标签应被拒绝")
|
||
.to_string();
|
||
assert!(msg.contains("不是 label_owner"), "实际: {msg}");
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// n = 3:三方各持一列
|
||
// ---------------------------------------------------------------------------
|
||
//
|
||
// 两方版能过不代表三方版能过。n 方纵向 LR 出错的地方不是"训练算错",
|
||
// 而是**分片广播的落点**:每方只该往自己的列块写,读到别人的片也只该
|
||
// 往别人的列块加。写错成"按收到的顺序排",值可能全对而列全串。
|
||
//
|
||
// 这里让三方各持一列,全局列序 [balance, spend, region],
|
||
// 与 `plaintext_expected()` 的 3 列逐项对应 —— 一旦串列,相关性立刻掉下来。
|
||
|
||
/// 三方各持一列:alice=balance、bob=spend(且是标签方)、carol=region。
|
||
fn sample_three() -> (Party, Party, Party) {
|
||
let (a, b) = sample();
|
||
let alice = Party {
|
||
site: "alice",
|
||
psi_seed: a.psi_seed,
|
||
ids: a.ids.clone(),
|
||
cols: vec![a.cols[0].clone()], // balance
|
||
y: vec![],
|
||
};
|
||
let bob = Party {
|
||
site: "bob",
|
||
psi_seed: b.psi_seed,
|
||
ids: b.ids.clone(),
|
||
cols: vec![b.cols[0].clone()], // spend(原 bob 的第 0 列)
|
||
y: b.y.clone(),
|
||
};
|
||
// carol 持 region:按 key 取值必须与 bob 原来那列一致
|
||
// key 1→0.0 2→0.0 3→0.0 4→0.5 5→0.5 8→0.5 9→0.5
|
||
// 本地行序 3,5,1,9,2,8,4,6(key 6 不在交集)
|
||
let carol = Party {
|
||
site: "carol",
|
||
psi_seed: [0x33; 32],
|
||
ids: vec![3, 5, 1, 9, 2, 8, 4, 6],
|
||
cols: vec![vec![0.0, 0.5, 0.0, 0.5, 0.0, 0.5, 0.5, 0.0]],
|
||
y: vec![],
|
||
};
|
||
(alice, bob, carol)
|
||
}
|
||
|
||
/// 跑三方会话(两条独立的全互联通道:PSI 一条、密态一条)。
|
||
fn run_triple(a: &Party, b: &Party, c: &Party) -> (PartyOut, PartyOut, PartyOut) {
|
||
let blocks = blocks_of(&[a, b, c]);
|
||
run_triple_with(a, b, c, blocks)
|
||
}
|
||
|
||
/// 同上,但列块清单由调用方给 —— 用于构造"列序 ≠ party 序"的场景。
|
||
fn run_triple_with(
|
||
a: &Party,
|
||
b: &Party,
|
||
c: &Party,
|
||
blocks: Vec<ColBlock>,
|
||
) -> (PartyOut, PartyOut, PartyOut) {
|
||
let d_total: usize = blocks.iter().map(|x| x.len).sum();
|
||
let cfgs = [
|
||
cfg_of(a, blocks.clone(), d_total, "bob"),
|
||
cfg_of(b, blocks.clone(), d_total, "bob"),
|
||
cfg_of(c, blocks, d_total, "bob"),
|
||
];
|
||
|
||
let mut psi = MeshPipe::mesh(3).into_iter();
|
||
let mut vault = MeshPipe::mesh(3).into_iter();
|
||
let mut handles = Vec::with_capacity(3);
|
||
for cfg in cfgs {
|
||
let p = psi.next().expect("3 个 PSI 端点");
|
||
let v = vault.next().expect("3 个密态端点");
|
||
handles.push(thread::spawn(move || {
|
||
run_lr_vertical_session(p, v, &cfg, false).map_err(|e| e.to_string())
|
||
}));
|
||
}
|
||
let mut it = handles.into_iter().map(|h| h.join().expect("线程 panic"));
|
||
(it.next().unwrap(), it.next().unwrap(), it.next().unwrap())
|
||
}
|
||
|
||
#[test]
|
||
fn vertical_lr_three_party_matches_plaintext() {
|
||
let (a, b, c) = sample_three();
|
||
let (ra, rb, rc) = run_triple(&a, &b, &c);
|
||
let (oa, wa) = ra.expect("alice 侧失败");
|
||
let (ob, wb) = rb.expect("bob 侧失败");
|
||
let (oc, wc) = rc.expect("carol 侧失败");
|
||
|
||
assert_eq!(oa.len(), 7, "三方交集应为 7 条");
|
||
assert_eq!(ob.len(), 7);
|
||
assert_eq!(oc.len(), 7);
|
||
|
||
// 三方必须对齐到同一批样本、同一个顺序
|
||
let keys = |p: &Party, o: &[usize]| -> Vec<u64> { o.iter().map(|&i| p.ids[i]).collect() };
|
||
assert_eq!(keys(&a, &oa), vec![1, 2, 3, 4, 5, 8, 9]);
|
||
assert_eq!(keys(&b, &ob), keys(&a, &oa), "bob 对齐后键序列不同");
|
||
assert_eq!(keys(&c, &oc), keys(&a, &oa), "carol 对齐后键序列不同");
|
||
|
||
// reveal 之后三方拿到同一份权重
|
||
assert_eq!(wa, wb, "alice/bob 权重分片还原后必须相同");
|
||
assert_eq!(wa, wc, "alice/carol 权重分片还原后必须相同");
|
||
|
||
let (x_plain, y_plain) = plaintext_expected();
|
||
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:?}"
|
||
);
|
||
// 三列特征同向,权重应同号(串列会让某个权重反号)
|
||
assert!(
|
||
w_enc[0] * w_enc[1] > 0.0 && w_enc[1] * w_enc[2] > 0.0,
|
||
"三列同向,权重应同号: {w_enc:?}"
|
||
);
|
||
}
|
||
|
||
/// 三方都声明自己是 label_owner 之外的 y 提供者时,必须**恰好一方**给 y。
|
||
/// 这条守的是 n 方最常见的一种静默错:标签被累加 n 次,训练照样收敛。
|
||
#[test]
|
||
fn three_party_label_is_not_double_counted() {
|
||
let (a, b, c) = sample_three();
|
||
let blocks = blocks_of(&[&a, &b, &c]);
|
||
let d_total: usize = blocks.iter().map(|x| x.len).sum();
|
||
|
||
// alice 声称 owner 却不是它 → 拒绝
|
||
let mut cfg = cfg_of(&a, blocks, d_total, "alice");
|
||
cfg.y = vec![]; // alice 是 owner 但没给标签
|
||
let mut psi = MeshPipe::mesh(3).into_iter();
|
||
let mut v = MeshPipe::mesh(3).into_iter();
|
||
let msg = run_lr_vertical_session(psi.next().unwrap(), v.next().unwrap(), &cfg, false)
|
||
.expect_err("owner 没给标签应被拒绝")
|
||
.to_string();
|
||
assert!(msg.contains("没给 --data-y"), "实际: {msg}");
|
||
let _ = c;
|
||
}
|
||
|
||
/// **列序 ≠ party 序**:party 下标是 2 的 carol 却持第 0 列,
|
||
/// party 下标是 0 的 alice 却持第 2 列。
|
||
///
|
||
/// 这条专门钉住"分片落列靠 party 下标还是靠列块 offset"。
|
||
/// 上面那条测试里两者恰好相等,写错成 `x_sh[i*d_total + j + k]` 也照样过 ——
|
||
/// 这正是 n 方 bug 的典型形态:两方时 `j` 和 `offset` 永远同值(0/1 或 1/0),
|
||
/// 三方且列序打乱时才分叉。
|
||
#[test]
|
||
fn three_party_column_order_differs_from_party_order() {
|
||
let (a, b, _c) = sample_three();
|
||
// alice 改持 region(全局第 2 列),carol 改持 balance(全局第 0 列)
|
||
let alice = Party {
|
||
site: "alice",
|
||
psi_seed: a.psi_seed,
|
||
ids: a.ids.clone(),
|
||
// 本地行序 7,2,4,1,8,3,9,5 → key 7 不在交集
|
||
cols: vec![vec![0.0, 0.0, 0.5, 0.0, 0.5, 0.0, 0.5, 0.5]],
|
||
y: vec![],
|
||
};
|
||
let bob = Party {
|
||
site: "bob",
|
||
psi_seed: b.psi_seed,
|
||
ids: b.ids.clone(),
|
||
cols: vec![b.cols[0].clone()], // spend = 全局第 1 列
|
||
y: b.y.clone(),
|
||
};
|
||
let carol = Party {
|
||
site: "carol",
|
||
psi_seed: [0x33; 32],
|
||
ids: vec![3, 5, 1, 9, 2, 8, 4, 6],
|
||
// 本地行序 → key 6 不在交集
|
||
cols: vec![vec![-0.5, 0.0, -1.0, 1.0, -0.75, 0.75, -0.25, 0.0]],
|
||
y: vec![],
|
||
};
|
||
|
||
// 清单按 party 序排(alice, bob, carol),但 offset 是 2, 1, 0
|
||
let blocks = vec![
|
||
ColBlock::new("alice", 2, 1),
|
||
ColBlock::new("bob", 1, 1),
|
||
ColBlock::new("carol", 0, 1),
|
||
];
|
||
let (ra, rb, rc) = run_triple_with(&alice, &bob, &carol, blocks);
|
||
let (oa, wa) = ra.expect("alice 侧失败");
|
||
let (_ob, wb) = rb.expect("bob 侧失败");
|
||
let (_oc, wc) = rc.expect("carol 侧失败");
|
||
assert_eq!(wa, wb, "权重必须一致");
|
||
assert_eq!(wa, wc, "权重必须一致");
|
||
|
||
let (x_plain, y_plain) = plaintext_expected();
|
||
let w_plain = plaintext_lr(&x_plain, &y_plain, 7, 3, 0.3, 40, 0.0, true);
|
||
let w_enc = decode_weights(&wa);
|
||
let r = corr(&w_plain, &w_enc);
|
||
assert!(
|
||
r > 0.95,
|
||
"列序与 party 序不同时仍须拼对,实际 r = {r:.4}\n 明文: {w_plain:?}\n 密态: {w_enc:?}"
|
||
);
|
||
assert_eq!(oa.len(), 7);
|
||
}
|