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
187 lines
7.6 KiB
Rust
187 lines
7.6 KiB
Rust
//! 端到端:编译一张 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());
|
||
}
|