Files
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

492 lines
16 KiB
Rust
Raw Permalink 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.
//! 迁移回归:把手写协议序列留在测试里当 **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 &degrees {
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 &degrees {
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(&reg_raw)?;
if cfg.fit_intercept {
reg[d_aug - 1] = 0;
}
w_sh = vault.sub_local(&w_sh, &reg)?;
}
}
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
);
}