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
492 lines
16 KiB
Rust
492 lines
16 KiB
Rust
//! 迁移回归:把手写协议序列留在测试里当 **oracle**,与图版本对话。
|
||
//!
|
||
//! # 为什么需要这个文件
|
||
//!
|
||
//! `mpc-ml` 原有的验收(`vertical_lr_end_to_end`)看的是「与明文实现的相关系数
|
||
//! > 0.95」。那条断言对**搬家**不够 —— 把 `trunc` 挪一位、把 `x_aug` 拼错一列,
|
||
//! 相关系数照样 0.99,但已经算错了。
|
||
//!
|
||
//! 这里把迁移前的实现原样抄下来(`legacy_*`),从两个角度比对:
|
||
//!
|
||
//! 1. **协议形状**:帧序列必须逐帧相同 —— 证明搬家没多花一个往返、也没少一次交互。
|
||
//! 2. **数值**:差异必须落在一个明确的舍入预算内。
|
||
//!
|
||
//! # 为什么不是「逐位相同」
|
||
//!
|
||
//! 这个文件的判据第一版写的就是逐位相等,结果红了。查下来不是迁移写错,而是
|
||
//! **`mpc-vault::truncate` 本身就是随机舍入**:
|
||
//!
|
||
//! ```text
|
||
//! c = x + r (r 是离线发的截断对,全环均匀)
|
||
//! cs = c >> fxp (算术右移)
|
||
//! out = cs − (r >> fxp)
|
||
//! ```
|
||
//!
|
||
//! 只有当 `x` 的低 `fxp` 位全为 0 时它才精确;而两个 fxp 编码数的乘积一般
|
||
//! 不是 `2^fxp` 的倍数,所以每次都会带一个由 `r` 决定的 ±1 ULP。这是**故意的**
|
||
//! (无偏舍入,避免定点右移的系统性偏低),不是 bug。
|
||
//!
|
||
//! 后果是:**同一段手写代码换个 seed 结果都会变**(`legacy_is_seed_sensitive`
|
||
//! 钉住这一点)。那么任何重排 —— 包括 IR 把同阶段的算子重新分组 —— 都会让低
|
||
//! 几位变化,「逐位相等」根本不是一个成立的判据。真正成立的是:协议调用形状
|
||
//! 相同、数值差落在舍入预算内。
|
||
|
||
use mpc_core::ring;
|
||
use mpc_ml::VerticalLR;
|
||
use mpc_vault::{Pipe, Transport, Vault, VaultError};
|
||
use std::collections::HashMap;
|
||
|
||
const FXP: u32 = 18;
|
||
|
||
fn enc(v: &[f64]) -> Vec<u64> {
|
||
v.iter().map(|x| ring::encode(*x, FXP).unwrap()).collect()
|
||
}
|
||
|
||
// --------------------------------------------------------------------------- //
|
||
// 迁移前的实现(逐字保留,只用来当 oracle)
|
||
// --------------------------------------------------------------------------- //
|
||
|
||
/// 迁移前的 `polynomial_odd`。
|
||
fn legacy_poly<T: Transport>(
|
||
vault: &mut Vault<T>,
|
||
t_sh: &[u64],
|
||
coeffs: &[f64],
|
||
) -> Result<Vec<u64>, VaultError> {
|
||
let len = t_sh.len();
|
||
|
||
let degrees: Vec<usize> = (1..coeffs.len()).filter(|&k| coeffs[k] != 0.0).collect();
|
||
|
||
let mut powers: HashMap<usize, Vec<u64>> = HashMap::new();
|
||
powers.insert(1, t_sh.to_vec());
|
||
|
||
fn get_power<T: Transport>(
|
||
vault: &mut Vault<T>,
|
||
k: usize,
|
||
powers: &mut HashMap<usize, Vec<u64>>,
|
||
) -> Result<Vec<u64>, VaultError> {
|
||
if let Some(v) = powers.get(&k) {
|
||
return Ok(v.clone());
|
||
}
|
||
let j = k / 2;
|
||
let left = get_power(vault, j, powers)?;
|
||
let right = get_power(vault, k - j, powers)?;
|
||
let prod = vault.mul_trunc(&left, &right)?;
|
||
powers.insert(k, prod.clone());
|
||
Ok(prod)
|
||
}
|
||
|
||
for &k in °rees {
|
||
if k > 1 {
|
||
get_power(vault, k, &mut powers)?;
|
||
}
|
||
}
|
||
|
||
let fxp = vault.fxp();
|
||
let mut acc = vec![0u64; len];
|
||
|
||
// 常数项:**只有 0 号持有**。两方各放一次会让重建变成 2·c₀。
|
||
if coeffs[0] != 0.0 {
|
||
let c0_enc =
|
||
ring::encode(coeffs[0], 2 * fxp).map_err(|e| VaultError::Crypto(e.to_string()))?;
|
||
if vault.my_index() == 0 {
|
||
for a in acc.iter_mut() {
|
||
*a = c0_enc;
|
||
}
|
||
}
|
||
}
|
||
|
||
for &k in °rees {
|
||
let pk = &powers[&k];
|
||
let ck_enc = ring::encode(coeffs[k], fxp).map_err(|e| VaultError::Crypto(e.to_string()))?;
|
||
for i in 0..len {
|
||
acc[i] = acc[i].wrapping_add(pk[i].wrapping_mul(ck_enc));
|
||
}
|
||
}
|
||
|
||
vault.truncate(&acc)
|
||
}
|
||
|
||
/// 迁移前的 `sigmoid_poly`。
|
||
fn legacy_sigmoid<T: Transport>(
|
||
vault: &mut Vault<T>,
|
||
x_sh: &[u64],
|
||
degree: usize,
|
||
) -> Result<Vec<u64>, VaultError> {
|
||
let (radius, coeffs) = mpc_ml::sigmoid_fit(degree)?;
|
||
let t_raw = vault.scale_public(x_sh, 1.0 / radius)?;
|
||
let t = vault.truncate(&t_raw)?;
|
||
legacy_poly(vault, &t, coeffs)
|
||
}
|
||
|
||
/// 迁移前的 `VerticalLR::fit`。
|
||
fn legacy_fit<T: Transport>(
|
||
vault: &mut Vault<T>,
|
||
cfg: &VerticalLR,
|
||
x_sh: &[u64],
|
||
n: usize,
|
||
d: usize,
|
||
y_sh: &[u64],
|
||
) -> Result<Vec<u64>, VaultError> {
|
||
let (x_aug, d_aug) = if cfg.fit_intercept {
|
||
let mut xa = vec![0u64; n * (d + 1)];
|
||
for i in 0..n {
|
||
xa[i * (d + 1)..i * (d + 1) + d].copy_from_slice(&x_sh[i * d..i * d + d]);
|
||
if vault.my_index() == 0 {
|
||
xa[i * (d + 1) + d] = ring::encode(1.0, vault.fxp())
|
||
.map_err(|e| VaultError::Crypto(e.to_string()))?;
|
||
}
|
||
}
|
||
(xa, d + 1)
|
||
} else {
|
||
(x_sh.to_vec(), d)
|
||
};
|
||
|
||
fn transpose(src: &[u64], rows: usize, cols: usize) -> Vec<u64> {
|
||
let mut out = vec![0u64; rows * cols];
|
||
for i in 0..rows {
|
||
for j in 0..cols {
|
||
out[j * rows + i] = src[i * cols + j];
|
||
}
|
||
}
|
||
out
|
||
}
|
||
|
||
let mut w_sh = vec![0u64; d_aug];
|
||
let scale = cfg.lr / n as f64;
|
||
|
||
for _ in 0..cfg.epochs {
|
||
let z = vault.matmul_trunc(&x_aug, n, d_aug, &w_sh, 1)?;
|
||
let p = legacy_sigmoid(vault, &z, cfg.sigmoid_degree)?;
|
||
let err = vault.sub_local(&p, y_sh)?;
|
||
let x_t = transpose(&x_aug, n, d_aug);
|
||
let grad = vault.matmul_trunc(&x_t, d_aug, n, &err, 1)?;
|
||
let step_raw = vault.scale_public(&grad, scale)?;
|
||
let step = vault.truncate(&step_raw)?;
|
||
w_sh = vault.sub_local(&w_sh, &step)?;
|
||
|
||
if cfg.l2 > 0.0 {
|
||
let reg_raw = vault.scale_public(&w_sh, cfg.lr * cfg.l2)?;
|
||
let mut reg = vault.truncate(®_raw)?;
|
||
if cfg.fit_intercept {
|
||
reg[d_aug - 1] = 0;
|
||
}
|
||
w_sh = vault.sub_local(&w_sh, ®)?;
|
||
}
|
||
}
|
||
Ok(w_sh)
|
||
}
|
||
|
||
// --------------------------------------------------------------------------- //
|
||
// 脚手架
|
||
// --------------------------------------------------------------------------- //
|
||
|
||
/// 把一份明文分好片,两方各持一片。返回 `(alice 的分片, bob 的分片)`。
|
||
fn split_once(values: &[f64]) -> (Vec<u64>, Vec<u64>) {
|
||
let sites = ["alice", "bob"];
|
||
let mut v = Vault::new(Pipe::pair().0, "alice", &sites, [5u8; 32], FXP).unwrap();
|
||
let all = v.split(&enc(values)).unwrap();
|
||
let len = values.len();
|
||
(all[0..len].to_vec(), all[len..2 * len].to_vec())
|
||
}
|
||
|
||
/// 记录帧类型序列的传输层。
|
||
struct Recorder<T> {
|
||
inner: T,
|
||
log: std::sync::Arc<std::sync::Mutex<Vec<String>>>,
|
||
}
|
||
|
||
impl<T: Transport> Transport for Recorder<T> {
|
||
fn send_to(&mut self, party: usize, frame: mpc_proto::Frame) -> Result<(), VaultError> {
|
||
self.log.lock().unwrap().push(format!("S{:?}", frame.op));
|
||
self.inner.send_to(party, frame)
|
||
}
|
||
|
||
fn recv_from(&mut self, party: usize) -> Result<mpc_proto::Frame, VaultError> {
|
||
let f = self.inner.recv_from(party)?;
|
||
self.log.lock().unwrap().push(format!("R{:?}", f.op));
|
||
Ok(f)
|
||
}
|
||
}
|
||
|
||
/// 两方跑一遍,返回(alice 侧公开结果,alice 侧帧序列)。
|
||
///
|
||
/// 两个闭包各自拿到自己的分片(已经捕获进去)。
|
||
fn run_two<FA, FB>(
|
||
a_share: Vec<u64>,
|
||
b_share: Vec<u64>,
|
||
alice: FA,
|
||
bob: FB,
|
||
) -> (Vec<u64>, Vec<String>)
|
||
where
|
||
FA: FnOnce(&mut Vault<Recorder<Pipe>>, &[u64]) -> Result<Vec<u64>, VaultError> + Send + 'static,
|
||
FB: FnOnce(&mut Vault<Pipe>, &[u64]) -> Result<Vec<u64>, VaultError> + Send + 'static,
|
||
{
|
||
let sites = ["alice", "bob"];
|
||
let seed = [7u8; 32];
|
||
let log = std::sync::Arc::new(std::sync::Mutex::new(Vec::new()));
|
||
|
||
let (pa, pb) = Pipe::pair();
|
||
let mut va = Vault::new(
|
||
Recorder {
|
||
inner: pa,
|
||
log: log.clone(),
|
||
},
|
||
"alice",
|
||
&sites,
|
||
seed,
|
||
FXP,
|
||
)
|
||
.unwrap();
|
||
let mut vb = Vault::new(pb, "bob", &sites, seed, FXP).unwrap();
|
||
|
||
let h = std::thread::spawn(move || {
|
||
let out = bob(&mut vb, &b_share).unwrap();
|
||
let _ = vb.reveal(&out).unwrap();
|
||
});
|
||
let out = alice(&mut va, &a_share).unwrap();
|
||
let out = va.reveal(&out).unwrap();
|
||
h.join().unwrap();
|
||
|
||
let seq = log.lock().unwrap().clone();
|
||
(out, seq)
|
||
}
|
||
|
||
/// 数往返突发:一段连续 `S` 加一段连续 `R` 算一个。
|
||
///
|
||
/// 批量之后帧序列不再逐帧相同(`SRSR` 变成 `SSRR`),但**帧数**应当不变、
|
||
/// **突发数**只该变少 —— 这就是迁移后新的协议形状判据。
|
||
fn bursts(seq: &[String]) -> usize {
|
||
let mut rounds = 0usize;
|
||
let (mut seen_send, mut seen_recv) = (false, false);
|
||
for c in seq {
|
||
if c.starts_with('S') {
|
||
if seen_recv {
|
||
rounds += 1;
|
||
seen_recv = false;
|
||
}
|
||
if !seen_send {
|
||
seen_send = true;
|
||
rounds += 1;
|
||
}
|
||
} else {
|
||
seen_recv = true;
|
||
}
|
||
}
|
||
rounds
|
||
}
|
||
|
||
/// 最大的逐元素差(单位:fxp 最低位)。
|
||
fn max_ulp_diff(a: &[u64], b: &[u64]) -> u64 {
|
||
a.iter()
|
||
.zip(b)
|
||
.map(|(x, y)| (*x as i64 - *y as i64).unsigned_abs())
|
||
.max()
|
||
.unwrap_or(0)
|
||
}
|
||
|
||
fn determinism_input() -> Vec<f64> {
|
||
vec![-4.5, -2.0, -0.25, 0.0, 0.75, 2.5, 4.5, 6.0]
|
||
}
|
||
|
||
// --------------------------------------------------------------------------- //
|
||
// 1. sigmoid:帧序列必须一样,数值落在舍入预算内
|
||
// --------------------------------------------------------------------------- //
|
||
|
||
#[test]
|
||
fn graph_sigmoid_keeps_the_same_protocol_shape() {
|
||
for degree in [3usize, 5, 7, 9] {
|
||
let (a, b) = split_once(&determinism_input());
|
||
|
||
let (aa, bb) = (a.clone(), b.clone());
|
||
let (want, seq_legacy) = run_two(
|
||
aa,
|
||
bb,
|
||
move |v, s| legacy_sigmoid(v, s, degree),
|
||
move |v, s| legacy_sigmoid(v, s, degree),
|
||
);
|
||
|
||
let (aa, bb) = (a.clone(), b.clone());
|
||
let (got, seq_graph) = run_two(
|
||
aa,
|
||
bb,
|
||
move |v, s| mpc_ml::sigmoid_poly(v, s, degree),
|
||
move |v, s| mpc_ml::sigmoid_poly(v, s, degree),
|
||
);
|
||
|
||
// 批量之后帧的**顺序**不再一样(`SRSR` → `SSRR`),但收发次数不该变:
|
||
// 批量只是把同样的帧重新分组。再要求往返数不增。
|
||
assert_eq!(
|
||
seq_graph.len(),
|
||
seq_legacy.len(),
|
||
"degree={degree}:收发帧数变了({} vs {})—— 批量只该改分组,不该改收发次数",
|
||
seq_graph.len(),
|
||
seq_legacy.len()
|
||
);
|
||
assert!(
|
||
bursts(&seq_graph) <= bursts(&seq_legacy),
|
||
"degree={degree}:图版本的往返变多了({} vs {})",
|
||
bursts(&seq_graph),
|
||
bursts(&seq_legacy)
|
||
);
|
||
let d = max_ulp_diff(&got, &want);
|
||
assert!(d <= 8, "degree={degree}:差 {d} ULP,超出舍入预算 8");
|
||
}
|
||
}
|
||
|
||
// --------------------------------------------------------------------------- //
|
||
// 2. 整条训练:帧序列一样,数值在预算内
|
||
// --------------------------------------------------------------------------- //
|
||
|
||
/// 训练用的固定小数据集。
|
||
fn lr_data() -> (Vec<f64>, Vec<f64>, usize, usize) {
|
||
let n = 12usize;
|
||
let d = 3usize;
|
||
let mut x = Vec::with_capacity(n * d);
|
||
for i in 0..n {
|
||
for j in 0..d {
|
||
x.push(((i * 7 + j * 3) % 11) as f64 / 5.0 - 1.0);
|
||
}
|
||
}
|
||
let y: Vec<f64> = (0..n)
|
||
.map(|i| f64::from(u8::from(i % 3 == 0)))
|
||
.collect();
|
||
(x, y, n, d)
|
||
}
|
||
|
||
#[test]
|
||
fn graph_lr_keeps_the_same_protocol_shape() {
|
||
let (x, y, n, d) = lr_data();
|
||
for (fit_intercept, l2) in [(true, 0.0f64), (false, 0.0), (true, 0.05)] {
|
||
let cfg = VerticalLR {
|
||
lr: 0.5,
|
||
epochs: 4,
|
||
l2,
|
||
sigmoid_degree: 7,
|
||
fit_intercept,
|
||
};
|
||
let (xa, xb) = split_once(&x);
|
||
let (ya, yb) = split_once(&y);
|
||
|
||
let (c1a, c1b) = (cfg_for(&cfg), cfg_for(&cfg));
|
||
let (xa1, xb1) = (xa.clone(), xb.clone());
|
||
let (ya1, yb1) = (ya.clone(), yb.clone());
|
||
let (want, seq_legacy) = run_two(
|
||
xa1,
|
||
xb1,
|
||
move |v, s| legacy_fit(v, &c1a, s, n, d, &ya1),
|
||
move |v, s| legacy_fit(v, &c1b, s, n, d, &yb1),
|
||
);
|
||
|
||
let (c2a, c2b) = (cfg_for(&cfg), cfg_for(&cfg));
|
||
let (xa2, xb2) = (xa.clone(), xb.clone());
|
||
let (ya2, yb2) = (ya.clone(), yb.clone());
|
||
let (got, seq_graph) = run_two(
|
||
xa2,
|
||
xb2,
|
||
move |v, s| c2a.fit(v, s, n, d, &ya2),
|
||
move |v, s| c2b.fit(v, s, n, d, &yb2),
|
||
);
|
||
|
||
assert_eq!(
|
||
seq_graph.len(),
|
||
seq_legacy.len(),
|
||
"fit_intercept={fit_intercept} l2={l2}:收发帧数变了({} vs {})",
|
||
seq_graph.len(),
|
||
seq_legacy.len()
|
||
);
|
||
assert!(
|
||
bursts(&seq_graph) <= bursts(&seq_legacy),
|
||
"fit_intercept={fit_intercept} l2={l2}:往返变多了({} vs {})",
|
||
bursts(&seq_graph),
|
||
bursts(&seq_legacy)
|
||
);
|
||
let diff = max_ulp_diff(&got, &want);
|
||
assert!(
|
||
diff <= 64,
|
||
"fit_intercept={fit_intercept} l2={l2}:差 {diff} ULP,超出舍入预算"
|
||
);
|
||
}
|
||
}
|
||
|
||
fn cfg_for(c: &VerticalLR) -> VerticalLR {
|
||
VerticalLR {
|
||
lr: c.lr,
|
||
epochs: c.epochs,
|
||
l2: c.l2,
|
||
sigmoid_degree: c.sigmoid_degree,
|
||
fit_intercept: c.fit_intercept,
|
||
}
|
||
}
|
||
|
||
// --------------------------------------------------------------------------- //
|
||
// 3. 把「截断是随机舍入」这件事钉住
|
||
// --------------------------------------------------------------------------- //
|
||
|
||
/// 同一段手写代码,只换随机物料(seed),结果就不同。
|
||
///
|
||
/// 这条测试不测实现,测的是**前提**:谁以后再想在这套代码上加「逐位相等」的
|
||
/// 断言,先看这里。
|
||
#[test]
|
||
fn legacy_is_seed_sensitive() {
|
||
let input = determinism_input();
|
||
let (a, b) = split_once(&input);
|
||
let sites = ["alice", "bob"];
|
||
|
||
let mut outs = Vec::new();
|
||
for seed_u8 in [7u8, 8] {
|
||
let seed = [seed_u8; 32];
|
||
let (pa, pb) = Pipe::pair();
|
||
let mut va = Vault::new(pa, "alice", &sites, seed, FXP).unwrap();
|
||
let mut vb = Vault::new(pb, "bob", &sites, seed, FXP).unwrap();
|
||
let (aa, bb) = (a.clone(), b.clone());
|
||
let h = std::thread::spawn(move || {
|
||
let p = legacy_sigmoid(&mut vb, &bb, 7).unwrap();
|
||
let _ = vb.reveal(&p).unwrap();
|
||
});
|
||
let p = legacy_sigmoid(&mut va, &aa, 7).unwrap();
|
||
let out = va.reveal(&p).unwrap();
|
||
h.join().unwrap();
|
||
outs.push(out);
|
||
}
|
||
assert_ne!(
|
||
outs[0], outs[1],
|
||
"换 seed 结果居然一样 —— 那说明截断已经被改成确定性右移了,\
|
||
这个文件的舍入预算判据可以收紧回逐位相等"
|
||
);
|
||
let d = max_ulp_diff(&outs[0], &outs[1]);
|
||
assert!(d <= 8, "换 seed 的差异 {d} ULP 过大,不只是舍入噪声");
|
||
}
|
||
|
||
// --------------------------------------------------------------------------- //
|
||
// 4. 轮数是报出来的,不是数出来的
|
||
// --------------------------------------------------------------------------- //
|
||
|
||
/// 一次迭代 13 轮(批量之前是 17):matmul 2 + sigmoid 8 + matmul 2 + scale 1。
|
||
///
|
||
/// sigmoid 那一跳从 12 降到 8,是因为同阶段的乘/截断/比较各自合成一批;
|
||
/// 剩下的 8 轮是「乘 → 截断」交替的层数,已经压不动了(每层都有真依赖)。
|
||
///
|
||
/// 这个数字在迁移前**没有任何地方**能回答 —— 只能人去数代码里出现了几次
|
||
/// `matmul_trunc` / `truncate`,还容易漏掉 `scale_public` 后面那次截断。
|
||
#[test]
|
||
fn epoch_rounds_are_reported() {
|
||
let cfg = VerticalLR::default();
|
||
let per = cfg.epoch_rounds(50, 4, FXP).unwrap();
|
||
assert_eq!(per, 13, "一次迭代应是 13 轮,实际 {per}");
|
||
assert_eq!(per * cfg.epochs, 520);
|
||
}
|
||
|
||
/// L2 分支多一次「乘公开系数 + 截断」,所以多 1 轮。
|
||
#[test]
|
||
fn l2_costs_exactly_one_more_round() {
|
||
let base = VerticalLR::default();
|
||
let with_l2 = VerticalLR {
|
||
l2: 0.1,
|
||
..VerticalLR::default()
|
||
};
|
||
assert_eq!(
|
||
with_l2.epoch_rounds(50, 4, FXP).unwrap(),
|
||
base.epoch_rounds(50, 4, FXP).unwrap() + 1
|
||
);
|
||
}
|