AI6 min read

Six Chinese open-weight models carry Nvidia Blackwell fingerprints in their weights

A former OpenAI researcher read a hardware fingerprint out of public model weights. It comes from a PyTorch initialisation behaviour that leaves the accelerator's streaming-multiprocessor count inside the tensors. Six models from four Chinese labs read as 148-SM B200/B300 or 152-SM GB200/GB300 parts. The method was reproduced on physical silicon, independently replayed on an H200 and a B200, and the code is public.

What happened

Summary of reporting by Unemployment Labs

Will DePue, a former OpenAI researcher now at Unemployment Labs, published on 12 November a forensic method that recovers a hardware fingerprint from published model weights (https://unemploymentlabs.com/checkpoint-forensics). The method reads accelerator-dependent values left in weight tensors by PyTorch's random initialisation, then maps them to a streaming-multiprocessor (SM) count for the part that produced them.

Applied to current open-weight releases, six models from four Chinese labs read as a 148-SM or 152-SM Nvidia part, matching B200/B300 or GB200/GB300: DeepSeek-V4-Flash, DeepSeek-V4-Pro, Moonshot's Kimi K3 and Kimi K3.1-Pro, MiniMax-M3, and Ant Group's Ling-3.1-flash. Earlier checkpoints from the same labs read as Hopper-class hardware.

DePue reproduced the match on physical B300 and GB200 systems and ruled out an AMD MI300X alternative for DeepSeek-V4-Flash, where the Nvidia part matched in 363 of 377 differing values. He is explicit about scope: the fingerprint identifies the class of accelerator that produced the initial random tensors, not who owned the hardware, where it ran, or whether an export rule was breached.

The finding landed as Jensen Huang resigned as Nvidia's chief executive and Congressional scrutiny of Nvidia's China sales intensified. Coverage: The Decoder (https://the-decoder.com/former-openai-researcher-says-he-found-nvidia-blackwell-fingerprints-hidden-inside-six-chinese-ai-models/), TechCrunch (https://techcrunch.com/2026/11/13/export-banned-nvidia-chips-are-behind-chinas-most-powerful-ai-models-uh-oh-jensen/) and Moneycontrol (https://www.moneycontrol.com/news/business/the-mystery-of-445-rows-nvidia-blackwell-chip-traces-found-in-6-chinese-ai-models-including-deepseek-ant-group-14079054.html).

The code is public at github.com/macrogrants/checkpoint-forensics under the MIT licence. Its replay.py rebuilds the untouched embedding rows for five models from the recovered seeds under every SM count from 16 to 256 with nothing but numpy and scipy, while gpu_check.py repeats the check with stock PyTorch on real hardware. The seeds were brute forced over all 2^32 values: DeepSeek reuses 953049583, Moonshot 20256586, MiniMax 2760 and Ant Group 3952.

Read the original at Unemployment Labs

The Azrty take

Model provenance is now a due-diligence question, and the tooling is public

For organisations in the UAE and the wider GCC that buy, fine-tune or host third-party open-weight models, this moves compute provenance from an unanswerable question to a routine one. Until now, nothing in a Hugging Face checkpoint told you which class of accelerator produced it. Now a public script does: the code and the preserved rows that reproduce each match are on GitHub (https://github.com/macrogrants/checkpoint-forensics), MIT licensed, and the check runs on a laptop in a few seconds. The security, compliance and procurement conversations that used to stop at the model card can include a falsifiable technical artefact. The legal question is separate and stays open: this does not show that any export rule was broken. The technical claim is reproducible by anyone, which is exactly why it will end up as a screening signal in vendor and model due diligence.

The mechanism is a PyTorch initialisation behaviour, not anything the labs did deliberately. For a large tensor, PyTorch's CUDA normal_ launches up to 2,048 threads per streaming multiprocessor and gives every thread its own Philox random stream, with the grid sized from the device's multiProcessorCount in calc_execution_policy, which sits in ATen's DistributionTemplates.h (https://github.com/pytorch/pytorch/blob/main/aten/src/ATen/native/cuda/DistributionTemplates.h). Element i is written by thread i mod G, where G is 2,048 times the SM count, so the same seed scatters the same numbers into different positions on different silicon. That gives 303,104 threads on a 148-SM B200 or B300 and 311,296 on a 152-SM GB200 or GB300, against 270,336 on a 132-SM H100, H800 or H200. Embedding rows for tokens that never appear in training never get a gradient, so they still hold their starting values. Read those back and the six models split into the 148-SM and 152-SM groups, which is what separates B200/B300 from GB200/GB300 and rules out a single-silicon story across all six. Older checkpoints from the same labs read as 132-SM Hopper, and the only alternative DePue could construct for DeepSeek-V4-Flash was AMD hardware in a two-way partition, which the value-level comparison ruled out.

The evidence quality is why this has traction: it was reproduced on physical B300 and GB200 systems rather than argued from theory, and then replayed by someone else. The Institute for Progress published an independent GPU run (https://github.com/Institute-for-Progress/checkpoint-forensics-verification-public) that re-downloaded the checkpoints, confirmed the hashes, and regenerated the matches for DeepSeek-V3-Base on an H200 and for DeepSeek-V4-Flash and MiniMax-M3 on a B200 using PyTorch 2.9.1 with CUDA 12.8: 445 of 469 rows bit-exact and 461 of 469 above r = 0.99 for V4-Flash, and 0 of 469 on the H200. It covered three of the eleven models, and could not test Kimi K3 without a 152-SM GPU. On the study side, the method is consistent with all 24 cases where a developer has publicly named the hardware, including NVIDIA's own Nemotron-3 Ultra, whose technical report names the GB200 and which reads as 152 SMs. Where teams will get this wrong is treating it as a smoking gun. A fully compliant lab can read as 148-SM through rented capacity in a third country, second-hand hardware or a compliant cloud region. This is a triage signal, not a conviction, and it should raise a question rather than answer one.

How Azrty would approach it: treat the fingerprint as an onboarding check rather than a one-off audit. When a team proposes an open-weight model, run the verifier against the checkpoint, record the SM count next to the model hash and the scanner version, and make the result a policy input rather than a footnote. Architecturally this belongs at the model gateway. FastLLM Proxy, our OpenAI-compatible gateway in front of self-hosted LLM servers and 80 hosted providers, is where we put it, so provenance becomes a first-class field beside routing, budgets and access control. For teams running their own accelerators on Kuvryn AI, the same record feeds capacity planning and licence mapping.

# Illustrative FastLLM Proxy catalogue entry with a provenance record
models:
  deepseek-v4-flash:
    upstream: self-hosted
    provenance:
      source: open-weight
      sm_count: 148            # from the public checkpoint verifier
      accelerator_class: B200/B300
      scanner_commit: pinned
      review: required
    policy:
      budget_usd_day: 500
      allowed_groups: [engineering, data]

The regional angle is straightforward. The UAE and the wider GCC are building domestic AI capacity inside a licensing regime written in Washington. The rule the study points at, 15 CFR 742.6 (https://www.ecfr.gov/current/title-15/subtitle-B/chapter-VII/subchapter-C/part-742/section-742.6), covers advanced computing items, and its paragraph (a)(13) requires a licence for AI model weights under ECCN 4E091 to all destinations worldwide, so the weights are in scope as well as the accelerators. Any organisation here that puts a Chinese open-weight model into production now carries a provenance question that a regulator, an auditor or a hyperscaler partner can ask, and answer, with public tooling. Better to have the record before they ask. Azrty's team in Dubai does this work day to day: mapping the model estate, wiring the checks into the gateway, and making the result something a CISO can sign.

What to do now

  1. Run the verifier from Unemployment Labs (https://unemploymentlabs.com/checkpoint-forensics) against every open-weight model in your catalogue or pilot, using the public code (https://github.com/macrogrants/checkpoint-forensics) and its gpu_check.py on your own silicon. Record the SM count beside the model hash and the scanner version in the registry you already use.
  2. Add a provenance field to your model gateway or registry config. In FastLLM Proxy it sits next to routing, budget and access control. Auto-promote Hopper-class results; route 148-SM or 152-SM results to named human sign-off before they take production traffic.
  3. Have counsel review the US export-control rules that govern the accelerators under your control against your actual hosting arrangements, not against the model weights (https://www.ecfr.gov/current/title-15/subtitle-B/chapter-VII/subchapter-C/part-742/section-742.6). If you host third-party weights in a free zone or a colo, the classification question is about the hardware.
  4. Re-run the scan quarterly. The signature depends on the PyTorch version and its initialisation behaviour (https://github.com/pytorch/pytorch/blob/main/aten/src/ATen/native/cuda/DistributionTemplates.h), so a torch upgrade can change what the scanner sees. Treat the SM count as a dated observation, not a permanent fact.
Put provenance checks in your AI platformWe design, build and run the gateway, GPU estate and pipelines your models sit on, with provenance, budgets and access control in one place.
AI infrastructuremodel provenanceexport controlsopen weightsGPUdue diligence

More from the Brief

Six Chinese open-weight models carry Nvidia Blackwell fingerprints in their weights: the Azrty take | Azrty Brief