权重里的硬件指纹:从 PyTorch 随机初始化反推训练用的 GPU

 

前置阅读:DeepSeek V4.1:拆分 Transformer,压缩 KV Cache

2026 年 11 月 12 日,Will DePue 发布了一份报告:只看公开权重,就判断出 DeepSeek-V4-Flash、V4-Pro、Kimi K3、K3.1-Pro、MiniMax-M3 和 Ling-3.1-flash 这 6 个模型是在 Blackwell 上初始化的,而同一批公司更早的模型都落在 Hopper 上。[1]

报告的结论偏政策,但它依赖的机制很工程:PyTorch 在 CUDA 上生成随机数时,线程排布取决于 GPU 的 SM 数;同一个 seed 在 132、148、152 个 SM 的卡上,会把同一串随机数写到不同的位置。 只要训练后还有一部分初始值留在权重里,就能反推出初始化时用的是哪一类 GPU。

1. 报告的结论

厂商 更早的模型 新模型 初始化硬件(SM 数)
DeepSeek V3(2024-12)、V3.2:Hopper V4-Flash(2026-04) B200/B300(148)
    V4-Pro(2026-04) GB200/GB300(152)
月之暗面 K2、K2.5:Hopper K3(2026-07)、K3.1-Pro GB200/GB300(152)
MiniMax M2.7 及之前:Hopper M3(2026-06) B200/B300(148)
蚂蚁 Ling-3.0-flash:Hopper Ling-3.1-flash(2026-10) GB200/GB300(152)

还有几处值得注意:

  • Qwen、GLM、腾讯、小米、阶跃星辰的最新模型仍是 Hopper 指纹。
  • Kimi K2.7-Code 是混合的:保留行里约 80% 继承 K2.5 的 Hopper 值,约 20% 是匹配 148 SM 的新抽样,而且每一行的混合比例一样。报告据此判断它是合并出来的 checkpoint,没有算进 6 个 Blackwell 模型里。
  • Hopper 指纹分不出 H800、H100 SXM 和 H200,因为它们都是 132 个 SM。报告表里的「H800」来自厂商自己的披露,不是这个方法测出来的。

2. 指纹从哪来:PyTorch 的 CUDA 随机数排布

nn.init.normal_、torch.randn 这类调用在 CUDA 上最终都走 aten/src/ATen/native/cuda/DistributionTemplates.h 里的 distribution_nullary_kernel。下面的代码引自 PyTorch v2.8.0,我也对照了 v2.4.0 和当前 main:这三版的启动配置和写入下标完全一样。[2]

2.1 grid 大小由 SM 数决定

const uint32_t block_size_bound = 256;

std::tuple<uint64_t, dim3, dim3> calc_execution_policy(const int64_t total_elements, const uint32_t unroll_factor) {
  const uint64_t numel = static_cast<uint64_t>(total_elements);
  const uint32_t block_size = block_size_bound;
  dim3 dim_block(block_size);
  dim3 grid((numel + block_size - 1) / block_size);
  uint32_t blocks_per_sm = at::cuda::getCurrentDeviceProperties()->maxThreadsPerMultiProcessor / block_size;
  grid.x = std::min(
      static_cast<uint32_t>(at::cuda::getCurrentDeviceProperties()->multiProcessorCount) * blocks_per_sm,
      grid.x);
  uint64_t counter_offset = ((numel - 1) / (block_size * grid.x * unroll_factor) + 1) * max_generator_offsets_per_curand_call;
  return std::make_tuple(counter_offset, grid, dim_block);
}

记 $S$ 为 SM 数,$M$ 为每个 SM 最多驻留的线程数,$N$ 为元素个数,那么:

\[B=256,\qquad G=\min\left(S\cdot\left\lfloor M/256\right\rfloor,\ \left\lceil N/256\right\rceil\right),\qquad T=G\cdot B.\]

权重矩阵动辄几百万元素,$G$ 一定会被前一项卡住,于是总线程数 $T=S\cdot M$。sm_90、sm_100、sm_103 的 $M$ 都是 2048,

消费级和工作站 Blackwell(sm_120,例如 RTX 5090、RTX PRO 6000)是 1536。[3]

硬件 SM 数 总线程数 $T$
A100 / A800 108 221,184
H100 SXM / H800 / H200 132 270,336
B200 / B300 148 303,104
GB200 / GB300 152 311,296
RTX 5090(sm_120) 170 261,120

报告给出的三个线程数(270,336、303,104、311,296)就是这里的 $T$。

2.2 每个线程把随机数写到哪里

auto [seed, offset] = at::cuda::philox::unpack(philox_args);
int64_t idx = ((int64_t) blockIdx.x) * blockDim.x + threadIdx.x;
curandStatePhilox4_32_10_t state;
curand_init(seed, idx, offset, &state);

int64_t rounded_size = ((numel - 1)/(blockDim.x * gridDim.x * unroll_factor)+1) *
    blockDim.x * gridDim.x * unroll_factor;
for(int64_t linear_index = idx; linear_index < rounded_size; linear_index += blockDim.x * gridDim.x * unroll_factor) {
  auto rand = dist_func(&state);
  #pragma unroll
  for (int ii = 0; ii < unroll_factor; ii++) {
    int64_t li = linear_index + blockDim.x * gridDim.x * ii;
    if (li < numel) {
      transform_func(li, static_cast<accscalar_t>((&rand.x)[ii]));
    }
  }
  __syncthreads();
}

每个线程用 curand_init(seed, 线程号, offset) 初始化自己的 Philox 状态,线程号就是 Philox 的 subsequence。[4]

每轮循环调用一次 curand_normal4(或 curand_uniform4)拿到 4 个值,分别写到 $li$、$li+T$、$li+2T$、$li+3T$,然后整体前进 $4T$。

这里的 4 是 sizeof(float4) / sizeof(accscalar_t)。fp16、bf16 的中间计算类型(accscalar_t)都是 float,所以和 fp32 一样是 4;fp64 用 curand_normal2_double,是 2。bf16 的 randn 先在 fp32 里算完 $\text{val}\cdot\text{std}+\text{mean}$,写回时才转成 bf16。

把写入下标倒过来,第 $i$ 个元素对应的是:

\[t=i\bmod T,\qquad k=\left\lfloor \frac{i}{4T}\right\rfloor,\qquad j=\left\lfloor \frac{i}{T}\right\rfloor \bmod 4,\]

也就是第 $t$ 个线程第 $k$ 次调用返回的第 $j$ 个分量。seed 决定每个 $(t,k,j)$ 上是什么数,$T$ 决定这个数落在哪个 $i$ 上。

同一 seed 在不同线程数下的排布

上图把规模缩小来示意(为了看清楚,每次调用只取 1 个值)。线程 0 在两边产生的是同一串数,48 线程时落在 0、48、96……,40 线程时落在 0、40、80……。两张图只有前 40 个位置相同,往后几乎全部错开。

换成真实规模:132 SM 和 148 SM 的排布在前 270,336 个元素上完全相同,从下标 270,336 开始分叉。一个 7168 维的 embedding 行只有 7168 个元素,单看一行分不出来,但词表矩阵有上亿个元素,排布差异会贯穿整个张量。

3. 训练后为什么会保留

最终权重等于初始值加上全部训练更新,训练只是往上叠,不会覆盖掉初始值。指纹有两种保存方式。

完整保留:从未出现过的 token。 词表里总有一些预留 token 或特殊 token 在训练数据里一次都没出现,对应的 embedding 行和输出层的行梯度恒为 0,Adam 的一阶、二阶矩也一直是 0,更新量就是 0。只要这些行不参与 weight decay,就能逐位保留初始值。报告用 DeepSeek 的 seed 953049583 做了真机验证:

  • 在 H100 上逐位复现了 V3 全部 57,344 个保留值(8 行 × 7168);
  • 在 B300 上验证了 V4-Flash 的 469 行:其中 8 行被训练动过一部分,其余 461 行全部复现(445 行逐位一致);
  • 在 H100 上复现不了 V4-Flash,在 B300 上也复现不了 V3;把 seed 改成 953049584,两台机器都一行也对不上。

Kimi K3 用月之暗面的 seed 20256586 在 GB200 上复现了全部 13 行保留行。

弱相关:训练过的权重。 如果更新量没有把初始差异完全淹没,最终值和初始值之间还会留下一点相关性。单个权重看不出来,但样本足够多时就显著了:V4-Flash 每层有 745,472 个注意力权重,相关系数 $r=0.066$,按 $r\sqrt N\approx0.066\times\sqrt{745472}\approx57$ 算,约 57σ。换成 Hopper 排布,这个相关性就消失了。

4. 怎么反推,怎么排除巧合

反推相当于一次二维搜索:枚举 seed 和排布,生成候选初始值,和权重里留下来的模式做比较,找最吻合的组合。

搜索空间约 6 万亿个组合,总会碰到一些偶然吻合。

报告估计,在正态模型下全空间最大的偶然匹配约 8σ,因此把 8σ 当作基准。实际结果是:每个模型最强的那项证据在 49σ 到 1,385σ 之间,最弱的单项(V4-Flash 训练过的注意力权重)也有 20σ。

另有两步交叉验证:

  1. 留出验证:用一部分权重选定 seed 和排布,再拿另一部分完全没参与搜索的权重去测。
  2. 已知答案:24 个公开披露过硬件的模型全部判对。例如 Llama 3.1 读出 132(H100),8 个 Pythia 读出 108(A100),NVIDIA 自己的 Nemotron-3 Ultra 读出 152,与技术报告里写的 GB200 一致。

5. 能证明了哪些东西

这类指纹能回答的问题很窄:

  • 只能说明初始化用了什么硬件。 权重完全可以在一套系统上生成,再搬到另一套系统上训练。混合集群也一样:NVIDIA 卡初始化、昇腾参与训练,权重里只会留下 NVIDIA 的痕迹。不过 Kimi K3 至少有 64 个各自设 seed 的进程都留下了 152 SM 排布。按一卡一进程推算,初始化阶段至少有几十张 GB200/GB300 参与,不是单机做完再搬走的(这是我的推断,报告没有这样换算)。
  • 有不少模型判断不了。 闭源模型没有权重可查;PaddlePaddle 的生成器不带硬件排布(ERNIE-5.5 只恢复出 seed 2760);在 CPU 上初始化的模型(部分 Qwen3)也没有 GPU 指纹。

参考

[1] Will DePue. Top Chinese Frontier AI Models Carry the Fingerprint of Export-Controlled NVIDIA Blackwell GPUs. Unemployment Labs, 2026-11-12. 报告原文,复现代码见 macrogrants/checkpoint-forensics。

[2] PyTorch. aten/src/ATen/native/cuda/DistributionTemplates.h:v2.8.0 L32–169,对照 v2.4.0;32 位下标拆分见 TensorIterator.cpp v2.8.0 L859–869、L1676–1697;generator offset 见 CUDAGeneratorImpl.cpp v2.8.0 L452–465。

[3] NVIDIA. CUDA Programming Guide, Compute Capabilities, Table 30;sm_103 的取值另见 CCCL arch_traits.h。

[4] NVIDIA. cuRAND Device API: Bit Generation with Philox 4x32-10. 文档。