feat(ml): 纵向 LR 接 PSI 行对齐

影响:两方各持不同客户名单时,能先 PSI 求交再密态训练纵向 LR;
此前 demo 隐含「行已对齐」,真实业务走不通。

- `nax_psi::align_by_key`:从测试上提为公开函数(PSI 结果的后处理),
  按共享键字节序排序;键重复即报错(一对多 join 不支持)。
- `run_lr_vertical_session`:两方各持不同客户、不同特征列的完整纵向 LR,
  PSI → align → 0 分片拼接列块。列块排布在碰网络前就校验。
- 新增 `tests/lr_vertical_psi.rs`(4 测):含变异检验——去掉排序后 2 条红。
This commit is contained in:
rong committed 2026-10-30 18:32:05 +08:00
1 parent c97da57c5f
commit 355d1be699
3 files changed
+569

No files matched your search

+222
View File
@@ -672,6 +672,228 @@ pub fn run_lr_session<T: Transport>(
Ok(w)
}
/// 真实纵向 LR 的配置:两方各持**不同客户**、**不同特征列**。
///
/// 与 [`LrConfig`] 的区别:那个假设两方行已对齐、列形状相同(demo 用,
/// 两方传同一份数据即可);这个从 PSI 开始 —— 行由求交决定,列由公开 schema 定位。
pub struct VerticalLrConfig {
/// 本方 site 名。
pub site: String,
/// 全体参与方(含本方)。目前只支持两方。
pub sites: Vec<String>,
/// 密态会话主种子(派生 Beaver 物料,**两方必须一致**)。
pub seed: [u8; 32],
/// 定点小数位。
pub fxp: u32,
/// 本方的 join 键(PSI 输入,长度 = 本方样本数)。
pub ids: Vec<Vec<u8>>,
/// PSI 会话种子。两方**必须不同** —— 同种子等于双方私钥相同,
/// ECDH 退化成共享标量,测不出真实的交换律。
pub psi_seed: [u8; 32],
/// 本方特征,行主序 `n_own × d_own`。
pub x: Vec<f64>,
/// 本方贡献的列数。
pub d_own: usize,
/// 本方列在**全局列序**里的起点(公开 schema)。
pub col_offset: usize,
/// 全局总列数(两方必须一致,等于两方 `d_own` 之和)。
pub d_total: usize,
/// 本方标签(长度 `n_own`);本方不持标签时留空,由对端提供。
pub y: Vec<f64>,
/// 训练轮数。
pub epochs: usize,
/// 学习率。
pub lr: f64,
}
/// 跑一次**真纵向** LR:先 PSI 求交、再按共享键对齐、再密态训练。
///
/// # 两条连接
///
/// PSI 与密态会话必须走**两条独立连接**。混用同一条会让帧串到对端的
/// `recv` 上 —— `PsiPoints` 与 `Shares` 的 op 不同,直接报协议错。
///
/// # 列怎么拼成一行
///
/// 两方各持自己的列块,在自己**不持有的列位置填 0 分片**,加和恰好
/// 等于列拼接 —— 因为两方的分片各自只在自己的列位置非零。
/// 所以 `VerticalLR::fit` 不用改:它看到的 `x_sh` 加和就是
/// `n × d_total` 的完整特征矩阵。
///
/// # 返回
///
/// `(对齐后的本方行下标, 权重)`。行下标是**本方原始行序**,
/// 调用方可用它核对两方是否对齐到了同一批样本。
pub fn run_lr_vertical_session<T: Transport>(
psi_transport: T,
vault_transport: T,
cfg: &VerticalLrConfig,
verbose: bool,
) -> Result<(Vec<usize>, Vec<u64>), NodeError> {
use nax_ml::VerticalLR;
if cfg.sites.len() != 2 {
return Err(NodeError::Session(format!(
"纵向 LR 目前只支持两方,得到 {} 方",
cfg.sites.len()
)));
}
if cfg.x.len() != cfg.ids.len() * cfg.d_own {
return Err(NodeError::Session(format!(
"特征长度 {} ≠ 样本数 {} × 本方列数 {}",
cfg.x.len(),
cfg.ids.len(),
cfg.d_own
)));
}
if !cfg.y.is_empty() && cfg.y.len() != cfg.ids.len() {
return Err(NodeError::Session(format!(
"标签长度 {} ≠ 样本数 {}",
cfg.y.len(),
cfg.ids.len()
)));
}
if cfg.col_offset + cfg.d_own > cfg.d_total {
return Err(NodeError::Session(format!(
"本方列块 [{}, {}) 超出总列数 {}",
cfg.col_offset,
cfg.col_offset + cfg.d_own,
cfg.d_total
)));
}
// 列块排布在**碰网络之前**就要定下来:两方场景只有两种合法排布
// (本方在前 / 本方在后)。悬空的列块会让拼出来的矩阵静默错位,
// 所以宁可在这里拒绝,也不要等到 PSI 跑完才发现。
let d_peer = cfg.d_total - cfg.d_own;
let peer_off = if cfg.col_offset == 0 {
cfg.d_own
} else if cfg.col_offset == d_peer {
0
} else {
return Err(NodeError::Session(format!(
"列块 [{}, {})、总列数 {} —— 只支持两方列块首尾相接(col_offset 必须为 0 或 {})",
cfg.col_offset,
cfg.col_offset + cfg.d_own,
cfg.d_total,
d_peer
)));
};
// 1) PSI:本方交集下标(本地行序升序)
let psi_cfg = PsiConfig {
site: cfg.site.clone(),
sites: cfg.sites.clone(),
ids: cfg.ids.clone(),
seed: cfg.psi_seed,
};
let hits = run_psi_session(psi_transport, &psi_cfg, verbose)?;
log(verbose, &format!("PSI 交集 {} 条", hits.len()));
// 2) 按共享规范键排序 —— 两方得到同一个顺序
let order = nax_psi::align_by_key(&cfg.ids, &hits).map_err(NodeError::Session)?;
let n = order.len();
log(verbose, &format!("对齐后 {n} 行"));
// 3) 只留交集行,并按对齐行序重排本方特征
let mut x_aligned = Vec::with_capacity(n * cfg.d_own);
for &row in &order {
x_aligned.extend_from_slice(&cfg.x[row * cfg.d_own..(row + 1) * cfg.d_own]);
}
let x_enc: Vec<u64> = x_aligned
.iter()
.map(|v| ring::encode(*v, cfg.fxp).map_err(|e| NodeError::Session(e.to_string())))
.collect::<Result<_, _>>()?;
// 4) 分片交换:本方留一片、对端给一片(先全发再全收,避免双向死锁)
let site_refs: Vec<&str> = cfg.sites.iter().map(|s| s.as_str()).collect();
let mut vault = Vault::new(vault_transport, &cfg.site, &site_refs, cfg.seed, cfg.fxp)?;
let peer_idx = 1 - vault.my_index();
let all_x = vault.split(&x_enc)?;
let x_mine = vault.my_slice(&all_x)?.to_vec();
vault.send_share(peer_idx, &all_x)?;
let x_peer = vault.recv_share()?;
if x_mine.len() != n * cfg.d_own {
return Err(NodeError::Session(format!(
"本方分片长度 {} ≠ n×d_own = {}×{}",
x_mine.len(),
n,
cfg.d_own
)));
}
if x_peer.len() != n * d_peer {
return Err(NodeError::Session(format!(
"对端分片长度 {} ≠ n×d_peer = {}×{} —— 两方对 d_total/d_own 的理解不一致",
x_peer.len(),
n,
d_peer
)));
}
// 5) 拼全局列序(`peer_off` / `d_peer` 已在入口定好并校验过)
let mut x_sh = vec![0u64; n * cfg.d_total];
for i in 0..n {
for k in 0..cfg.d_own {
x_sh[i * cfg.d_total + cfg.col_offset + k] = x_mine[i * cfg.d_own + k];
}
// 对端列块:加和即拼接(本方在这些位置是 0)
for k in 0..d_peer {
let slot = &mut x_sh[i * cfg.d_total + peer_off + k];
*slot = slot.wrapping_add(x_peer[i * d_peer + k]);
}
}
log(
verbose,
&format!("特征拼接完成 ({n} 行 × {} 列)", cfg.d_total),
);
// 6) 标签:只有一方提供,另一方按全零分片参与(全零 split 后加和为 0)
let y_enc: Vec<u64> = if cfg.y.is_empty() {
vec![0u64; n]
} else {
let mut out = Vec::with_capacity(n);
for &row in &order {
out.push(
ring::encode(cfg.y[row], cfg.fxp)
.map_err(|e| NodeError::Session(e.to_string()))?,
);
}
out
};
let all_y = vault.split(&y_enc)?;
let y_mine = vault.my_slice(&all_y)?.to_vec();
vault.send_share(peer_idx, &all_y)?;
let y_peer = vault.recv_share()?;
let y_sh: Vec<u64> = y_mine
.iter()
.zip(y_peer.iter())
.map(|(a, b)| a.wrapping_add(*b))
.collect();
log(verbose, "y 分片交换完成");
// 7) 训练(d 传全局列数,两方一致)
let model = VerticalLR {
lr: cfg.lr,
epochs: cfg.epochs,
l2: 0.0,
sigmoid_degree: 7,
fit_intercept: true,
};
log(
verbose,
&format!("开始训练 ({} 轮, lr={}, d_total={})", cfg.epochs, cfg.lr, cfg.d_total),
);
let w_sh = model
.fit(&mut vault, &x_sh, n, cfg.d_total, &y_sh)
.map_err(|e| NodeError::Session(e.to_string()))?;
let w = vault.reveal(&w_sh)?;
log(verbose, "训练完成");
Ok((order, w))
}
#[cfg(test)]
mod tests {
use super::*;
+311
View File
@@ -0,0 +1,311 @@
//! 真纵向 LR 端到端:两方各持**不同客户**、**不同特征列**。
//!
//! ```text
//! PSI(本方交集下标,本地行序)
//! → nax_psi::align_by_key(按共享键字节序重排,两方同一顺序)
//! → 各在自己不持有的列位置填 0 分片 → 加和即列拼接
//! → VerticalLR::fit(密态)→ reveal → 对拍明文
//! ```
//!
//! # 这条测试要守什么
//!
//! 既有的 `nax 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 nax_core::ring;
use nax_ml::plaintext_lr;
use nax_node::{run_lr_vertical_session, VerticalLrConfig};
use nax_psi::id_from_u64;
use nax_vault::Pipe;
const FXP: u32 = 18;
const SITES: [&str; 2] = ["alice", "bob"];
/// 一方:自己的客户名单 + 自己的特征列 + 可能的标签。
#[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 cfg_of(p: &Party, col_offset: usize, d_total: usize) -> VerticalLrConfig {
VerticalLrConfig {
site: p.site.to_string(),
sites: SITES.iter().map(|s| s.to_string()).collect(),
seed: [0x5Bu8; 32], // 密态主种子:两方必须一致
fxp: FXP,
ids: p.keys(),
psi_seed: p.psi_seed,
x: p.x_flat(),
d_own: p.d_own(),
col_offset,
d_total,
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 d_total = a.d_own() + b.d_own();
let (psi_a, psi_b) = Pipe::pair();
let (va, vb) = Pipe::pair();
let ca = cfg_of(a, 0, d_total);
let cb = cfg_of(b, a.d_own(), d_total);
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 = nax_psi::align_by_key(&ka, &hits_a).unwrap();
let ob = nax_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, _) = sample();
// d_total=5、d_own=1、col_offset=2 → 中间悬空
let cfg = cfg_of(&a, 2, 5);
let (psi, _psi_peer) = Pipe::pair();
let (v, _v_peer) = Pipe::pair();
// 对端缺席无所谓:入口校验在**碰网络之前**就该拒绝
let r = run_lr_vertical_session(psi, v, &cfg, false);
assert!(r.is_err(), "悬空列块应在开始时被拒绝");
}
+36
View File
@@ -133,6 +133,42 @@ pub fn resolve(perm: &[usize], positions: &[usize]) -> Vec<usize> {
out
}
/// 把「本方落在交集里的行」按**共享规范键**排序,返回按对齐行序排列的行下标。
///
/// # 为什么必须排序
///
/// [`resolve`] 返回的是**本地行序**升序的下标 —— 两方拿到的序列互不相同,
/// 也不含共享顺序。下游的纵向拼接(同一个人在两方各有一行,拼成一行特征)
/// 要求「两方第 i 行是同一个人」,所以两边必须按同一个**全序**重排。
/// 这里用键的字节序:任何两方一致的全序都行,关键是别用本地行序。
///
/// 副作用(已知且接受):排序暴露了本方键相对对端键的秩,与 PSI 本身
/// 泄露交集是同一量级的元信息;不排序则结果直接错 —— 不崩、不报错,就是数不对。
///
/// # 三种失败
///
/// - **交集为空**:两方没有公共样本。继续往下跑会拿空列去 open,在此明确失败。
/// - **下标越界**:协议错乱的信号,不能当成正常情况处理。
/// - **本方键重复**:对应一对多 join,纵向对齐(一人一行)表达不了笛卡尔展开,
/// 必须在切分片**之前**拒绝,而不是按行号静默错拼。
pub fn align_by_key(keys: &[Vec<u8>], hits: &[usize]) -> Result<Vec<usize>, String> {
if hits.is_empty() {
return Err("交集为空:两方没有可对齐的行".into());
}
if let Some(&bad) = hits.iter().find(|&&i| i >= keys.len()) {
return Err(format!("PSI 交集中出现越界下标 {bad}"));
}
let mut order = hits.to_vec();
order.sort_by(|&x, &y| keys[x].cmp(&keys[y]));
if let Some(w) = order.windows(2).find(|w| keys[w[0]] == keys[w[1]]) {
return Err(format!(
"join 键在本方重复(第 {} 与第 {} 行),一对多 join 不支持",
w[0], w[1]
));
}
Ok(order)
}
/// Fisher–Yates 洗牌,随机源用会话 PRG。
fn shuffle(v: &mut [usize], s: &mut Stream) {
let n = v.len();