Files
ssw-mpc/crates/mpc-node/tests/lr_vertical_psi.rs
T
admin 54781b3f83
ci / gate (push) Waiting to run
refactor: 项目改名 ssw-mpc,crate 统一到 mpc-* 前缀
- 项目与文档标题: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
2026-11-05 15:06:12 +08:00

559 lines
21 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! 真纵向 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);
}