Files
ssw-mpc/crates/mpc-ir/tests/e2e.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

187 lines
7.6 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 梯度的图,**两方真 Vault 跑出来**,与明文逐位对比。
//!
//! 这张图是刻意挑的,它同时覆盖四件事:
//!
//! 1. `matmul` / `sub` / `transpose` / `add` / `scale` / `open` 都在图上;
//! 2. 有两次 `open` 落在同一阶段 —— 必须合成**一次**往返;
//! 3. 有一个公开常量进入密态表达式 —— 必须走 `lift`,且明文**只出现在 0 号**;
//! 4. 整数系数的 `scale` 是纯本地的,不该产生往返。
//!
//! 第 3 条是重点:如果 `lift` 写错成「每方都带一份明文」,结果会变成
//! `w + 2·c` 而不是 `w + c` —— **能跑通、不报错、数是错的**。
//! 这正是 mpc 栽过两次的那类 bug,所以它必须有一条自己的用例。
use mpc_core::prg::Stream;
use mpc_core::ring;
use mpc_core::share::split_into;
use mpc_ir::{run, Graph, Plan, Shape};
use mpc_vault::{Pipe, Vault};
const FXP: u32 = 0; // 整数输入,量化误差为零,能要求逐位相等
/// 把一个明文张量**确定性地**拆成 `n` 份。两方各自算一遍会得到同一组分片,
/// 所以测试不需要额外的分发协议。
fn shares_of(vals: &[f64], n: usize, seed: [u8; 32], tag: &[u8]) -> Vec<Vec<u64>> {
let mut enc = vec![0u64; vals.len()];
ring::encode_into(vals, FXP, &mut enc).unwrap();
let mut stream = Stream::derive(&seed, tag);
let mut buf = vec![0u64; n * vals.len()];
split_into(&enc, n, &mut stream, &mut buf, FXP).unwrap();
(0..n)
.map(|p| buf[p * vals.len()..(p + 1) * vals.len()].to_vec())
.collect()
}
/// 建图。返回图本身,输出是两个待 `open` 的值。
fn build_graph() -> (Graph, mpc_ir::Val, mpc_ir::Val) {
let mut g = Graph::new();
let x = g.input(Shape::new(3, 2)); // 3 行 2 列特征
let w = g.input(Shape::new(2, 1)); // 权重
let y = g.input(Shape::new(3, 1)); // 标签
let pred = g.matmul(x, w).unwrap(); // 2 轮
let err = g.sub(pred, y).unwrap(); // 0 轮
let xt = g.transpose(x); // 0 轮
let grad = g.matmul(xt, err).unwrap(); // 2 轮
let lr = 2.0; // 整数系数 → 纯本地
let upd = g.scale(grad, lr).unwrap(); // 0 轮
let w2 = g.add(w, upd).unwrap(); // 0 轮
let bias = g
.constant(vec![100, 100], Shape::new(2, 1))
.unwrap(); // 公开常量
let w3 = g.add(w2, bias).unwrap(); // 触发 lift,0 轮
let out_w = g.open(w3); // 1 轮
let out_g = g.open(grad); // 1 轮,与上一个同阶段
(g, out_w, out_g)
}
#[test]
fn compiled_plan_matches_the_plaintext_numbers() {
let seed = [42u8; 32];
let (g, out_w, out_g) = build_graph();
let plan = Plan::compile(g).unwrap();
// 编译期的账要能对上:两次 open 落在同一阶段,所以是 5 轮而不是 6 轮
assert_eq!(plan.rounds(), 5, "{}", plan.summary());
let shared = plan
.stages()
.iter()
.find(|s| s.comm.len() == 2)
.expect("两次 open 必须落在同一个阶段");
assert!(
shared.comm.contains(&out_w) && shared.comm.contains(&out_g),
"两个 open 应同阶段:{}",
plan.summary()
);
// 输入(两方各自拿自己那一片)
let x = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0];
let w = [2.0, 3.0];
let y = [1.0, 2.0, 3.0];
let sx = shares_of(&x, 2, seed, b"x");
let sw = shares_of(&w, 2, seed, b"w");
let sy = shares_of(&y, 2, seed, b"y");
let plan = std::sync::Arc::new(plan);
let (pa, pb) = Pipe::pair();
let sites = ["alice", "bob"];
let (sx1, sw1, sy1) = (sx[1].clone(), sw[1].clone(), sy[1].clone());
let p1 = plan.clone();
let hb = std::thread::spawn(move || {
let mut v = Vault::new(pb, "bob", &sites, seed, FXP).unwrap();
let ins: Vec<&[u64]> = vec![&sx1, &sw1, &sy1];
let vals = run(&p1, &mut v, &ins, FXP).unwrap();
(vals.decoded(out_w).unwrap(), vals.decoded(out_g).unwrap())
});
let mut va = Vault::new(pa, "alice", &sites, seed, FXP).unwrap();
let ins: Vec<&[u64]> = vec![&sx[0], &sw[0], &sy[0]];
let vals = run(&plan, &mut va, &ins, FXP).unwrap();
let (aw, ag) = (vals.decoded(out_w).unwrap(), vals.decoded(out_g).unwrap());
let (bw, bg) = hb.join().unwrap();
// 明文真值
// pred = [1·2+2·3, 3·2+4·3, 5·2+6·3] = [8, 18, 28]
// err = pred − y = [7, 16, 25]
// grad = xᵀ·err = [1·7+3·16+5·25, 2·7+4·16+6·25] = [180, 228]
// upd = 2·grad = [360, 456]
// w2 = w + upd = [362, 459]
// w3 = w2 + bias = [462, 559]
assert_eq!(ag, vec![180.0, 228.0], "梯度不对");
assert_eq!(aw, vec![462.0, 559.0], "权重不对(偏置被加了两次?)");
assert_eq!(aw, bw, "两方的明文结果必须一致");
assert_eq!(ag, bg, "两方的明文结果必须一致");
}
/// `lift` 只让 0 号带明文。写错成每方都带一份,结果会是 `w + 2·bias`。
///
/// 这条用例的价值在于:错误形态是**能收敛、不报错、数是错的**,
/// 所以只能靠“拿正确值钉死”来抓,不能靠“跑得过”来判。
#[test]
fn lifted_constant_appears_exactly_once() {
let seed = [7u8; 32];
let mut g = Graph::new();
let w = g.input(Shape::vec(2));
let c = g.constant(vec![100, 100], Shape::vec(2)).unwrap();
let s = g.add(w, c).unwrap();
let o = g.open(s);
let plan = std::sync::Arc::new(Plan::compile(g).unwrap());
let sw = shares_of(&[1.0, 2.0], 2, seed, b"w");
let (pa, pb) = Pipe::pair();
let sites = ["alice", "bob"];
let w1 = sw[1].clone();
let p1 = plan.clone();
let hb = std::thread::spawn(move || {
let mut v = Vault::new(pb, "bob", &sites, seed, FXP).unwrap();
run(&p1, &mut v, &[&w1], FXP).unwrap().decoded(o).unwrap()
});
let mut va = Vault::new(pa, "alice", &sites, seed, FXP).unwrap();
let got = run(&plan, &mut va, &[&sw[0]], FXP).unwrap().decoded(o).unwrap();
let peer = hb.join().unwrap();
assert_eq!(got, vec![101.0, 102.0], "公开常量被加了 {} 次", {
// 差分只为把错误信息说清楚:多一份就是多 100
(got[0] - 1.0) / 100.0
});
assert_eq!(peer, got);
}
/// 只有一条本地链的图必须 **0 轮**:一个交互算子都不该有。
#[test]
fn local_only_graph_sends_nothing() {
let seed = [9u8; 32];
let mut g = Graph::new();
let x = g.input(Shape::vec(3));
let c = g.constant_f64(FXP, &[1.0, 1.0, 1.0], Shape::vec(3)).unwrap();
let a = g.add(x, c).unwrap();
let b = g.scale(a, 3.0).unwrap();
let t = g.transpose(b);
let s = g.sum(t);
let plan = Plan::compile(g).unwrap();
assert_eq!(plan.rounds(), 0, "{}", plan.summary());
assert_eq!(plan.comm_ops(), 0, "{}", plan.summary());
// 真跑两方:既然全程本地,两方各自算自己那份,不需要任何帧
let sx = shares_of(&[1.0, 2.0, 3.0], 2, seed, b"x");
let (pa, pb) = Pipe::pair();
let sites = ["alice", "bob"];
let plan = std::sync::Arc::new(plan);
let x1 = sx[1].clone();
let p1 = plan.clone();
let hb = std::thread::spawn(move || {
let mut v = Vault::new(pb, "bob", &sites, seed, FXP).unwrap();
run(&p1, &mut v, &[&x1], FXP).unwrap().get(s).to_vec()
});
let mut va = Vault::new(pa, "alice", &sites, seed, FXP).unwrap();
let mine = run(&plan, &mut va, &[&sx[0]], FXP).unwrap().get(s).to_vec();
let theirs = hb.join().unwrap();
// (x + 1) · 3 求和 = (2+3+4)·3 = 27
let total = ring::decode(mine[0].wrapping_add(theirs[0]), FXP);
assert_eq!(total, 27.0, "本地链算错了:{total}");
assert!(plan.summary().contains("往返 0 轮"), "{}", plan.summary());
}