
When a lab open-sources a model, the weights it hands over carry a record of the instant before training began: the way a GPU fills billions of initial values differs by chip generation, and a small fraction of that arrangement survives all the way to release. A one-person study reads from this that six of this year's models from four Chinese labs were initialized on export-controlled Blackwell—and the author even rented a GB200 to reproduce it live. But that is exactly as far as the fingerprint reaches: where the chips are, who owns them, whether rules were broken—the weights say nothing. How the method works, how strong the evidence is, and where the limits sit are what this article is about.
Set the random seed to 953049583 and run unmodified PyTorch on a B300: of 469 selected rows of weights from DeepSeek-V4-Flash, 461 are regenerated with correlations above 0.99, and 445 of them match the published version bit for bit.
This is not retraining a model. It repeats a single action that happens before training starts: assigning initial values to parameters. Some of the weights that went through months of training and were then packaged for release still look exactly the way they did at the beginning.
On November 12, 2026, Will DePue published a study on his personal site, Unemployment Labs: six models released since April by DeepSeek, Moonshot AI, MiniMax, and Ant Group carry numerical fingerprints consistent with initialization on NVIDIA Blackwell, while earlier models from the same lineages mostly carry Hopper traces. The claim is easy to compress into a sensational headline, but the report's evidence is considerably more precise than a headline: what it traces is how initial weights were generated, which supports a judgment about initialization hardware. What the rest of the training ran on, where the chips are, who owns them, and whether export rules were violated requires other evidence.
The report was published as personal research, is not peer-reviewed, and contains no response from any of the named labs; the model readings and reproduction experiments below all come from the author's disclosure. On November 13 the report linked a public verification repository with some preserved weights, reconstruction scripts, and machine checks—the check runs on a laptop in seconds, and a second script repeats it with unmodified PyTorch on a GPU. The full search process and statistical treatment remain outside the repository and need separate examination. On the author's background, only verifiable facts: DePue says he formerly worked at OpenAI on Sora 1&2 development and o3/4o post-training, and his X and LinkedIn bios both read "ex-/prev OpenAI." This article does not speculate about motives; all findings are relayed as a single study's claims.
The report measures evidence strength in sigma (standard deviations)—the higher the number, the further the observation sits from a chance match. Each of the six models' strongest readings falls between 49σ and 1,385σ; how that scale was set, and how much weight it can bear, is the subject of Section 3.
1. Random Numbers Have a Shift Schedule
To understand the method, go back to when the model did not yet know anything.
Before training begins, parameters need initial values. In the implementation the report examines, those values come from the Philox pseudorandom algorithm: the numbers look disordered, yet they can be regenerated exactly when the algorithm, its state, and the execution conditions are fixed. The random seed is where the process starts.
Regenerating a set of weights, however, takes more than producing the same numbers—the numbers must also land in the same positions.
To fill enormous parameter tensors quickly, PyTorch divides the work among many GPU threads; each thread owns a stream of random numbers and a set of write positions. The framework picks the thread grid from device attributes such as the SM count (an SM is a streaming multiprocessor, a group of compute units). Change the grid and the same random stream lands in different places in the weights. On the initialization path the report examines, when the tensor is large enough, the total thread count reaches SM count × 2,048. Several hardware configurations thus produce distinct arrangements:
| Hardware configuration | SMs | Initialization thread grid |
|---|---|---|
| Ampere A100 / A800 | 108 | 221,184 |
| Hopper H100 SXM / H200 / H800 | 132 | 270,336 |
| Blackwell B200 / B300 | 148 | 303,104 |
| Blackwell GB200 / GB300 | 152 | 311,296 |
The 148 and 152 figures correspond to two Blackwell configurations; they cannot further distinguish a B200 from a B300, or a GB200 from a GB300. The thread counts likewise refer specifically to the execution grid this initialization path selects.
Shrink the scale and it becomes intuitive. A toy GPU with 6 SMs and 8 threads per SM has 48 threads taking turns filling a row of boxes: thread 0 handles boxes 1, 49, and 97, writing every 48th box. A 5-SM toy GPU has 40 threads. Keep the random-number conditions identical, and thread 0 still generates the same numbers—but they now land in boxes 1, 41, and 81. Same numbers, different positions. In the toy matrix the report shows, only about 6 percent of positions still agree between the two arrangements.
In this simplified model, the seed decides what numbers each thread generates, and the thread grid decides where they are written. During the search, both conditions must hold simultaneously: right seed, wrong grid, and the correct numbers land in the wrong places; right grid, wrong seed, and a different set of numbers is generated entirely.

The genuinely surprising part is that the arrangement can survive to the end of training.
The first class of traces comes from parameters that still hold their initialization structure, including embedding rows that never received meaningful updates—weights bound to rare tokens that training never touched. They can be compared directly against values regenerated from candidate seeds and layouts (the report's "exact copy," correlation r>0.999; clipped or rounded models drop to r≈0.98), and some samples reproduce bit for bit on real machines. "Highly correlated" and "bit-for-bit identical" are different things: the former says two sets of numbers move together; the latter requires the stored representations to be exactly the same—a much more specific result.
The second class hides inside parameters that training did change. A final weight equals its initial value plus every training adjustment; as long as the adjustments do not completely swamp the initial differences, a faint association can still be detected across enough parameters. The report ran this analysis over all 42 layers of V4-Flash, averaging about 745,000 weights per layer: under the Blackwell layout, parameters with larger starting values end slightly larger (r=0.066, 57σ); under Hopper the relationship vanishes. The correlation is weak; the sample size makes it detectable. The author notes himself that this is "a finding in these weights, not a property guaranteed to survive every training run."

2. Six Models, Two Blackwell Layouts
Following this thread, the report reads two Blackwell-consistent layouts in six models from four labs.
| Lab | Model (released) | Layout read | Evidence |
|---|---|---|---|
| DeepSeek | V4-Flash (2026-04) | 148 SM: B200/B300 | 1,385σ, exact copy |
| DeepSeek | V4-Pro (2026-04) | 152 SM: GB200/GB300 | 49σ, partial survival |
| Moonshot AI | Kimi K3 (2026-07) | 152 SM: GB200/GB300 | 305σ, exact copy |
| Moonshot AI | K3.1-Pro (2026-11) | 152 SM: GB200/GB300 | same seed as K3, 305σ |
| MiniMax | M3 (2026-06) | 148 SM: B200/B300 | 323σ, exact copy |
| Ant Group | Ling-3.1-flash (2026-10) | 152 SM: GB200/GB300 | 244σ, untrained rows r≈0.98 |
The σ values are standardized match scores computed under a specific statistical model; they measure how far the observation sits from a random baseline and cannot be read as "the probability the attribution is correct." The report's own phrasing for what these readings mean is restrained: the fingerprints "support, but do not by themselves prove" that training ran on Blackwell.
Lined up by series, the models form a suggestive timeline. DeepSeek's Blackwell layouts appear from V4, MiniMax's from M3, Moonshot's from K3, Ant's at Ling-3.1-flash; the corresponding earlier versions—V3, M2.7, K2.5, Ling-3.0—all read as Hopper, and some of DeepSeek's earliest models carry Ampere (108 SM) traces. Note that these timestamps come from release dates: they mark when the new initialization signature appears in public models, not when a lab acquired hardware or started using it.
The same report provides a Hopper control: Zhipu's GLM-5.3, Alibaba's Qwen3.8 and Qwen3.5-397B, Tencent's Hy4-preview, StepFun's Step-5-Preview, and Xiaomi's MiMo-V2.5-Pro—five labs, six models—all read as the 132-SM layout (41–478σ). That layout is compatible with the H100 SXM, H200, and H800 alike; the method cannot split them. The same method gives readings for labs that never switched chips, and reports honestly when it cannot read a model at all.
K3.1-Pro shares its seed with K3, and the author suggests the former may be a checkpoint of the latter with further post-training. Shared seeds alone, though, do not establish lineage—DeepSeek's V3 and V4-Flash also share one seed (953049583) in the report.
3. Making the Match Withstand Scrutiny
Finding an arrangement inside a mountain of numbers does not automatically mean a hardware fingerprint. The larger the search space, the more opportunities for a beautiful result to appear by accident.
The report first runs hold-out validation: search for a seed and layout using one set of weights, then use that combination to predict a second set that played no part in the search, without going back to tune. A match that extends to numbers never used in the selection carries more weight than a high score inside the searched sample.
Next, a reference line for chance. The full search covers roughly 6 trillion seed-and-layout combinations; under the author's normal model, the chance probability of a single 5σ match is about one in 3.5 million—tiny for one experiment, less so across trillions of attempts. The report therefore uses about 8σ as the reference line for the best accidental match across the whole search. All six models clear it: 49σ to 1,385σ, with the weakest individual test at 20σ. These numbers carry one premise: that the statistical model correctly describes the random variation in the data. A higher score rules out chance under that model; it does not automatically rule out some other generation mechanism.

Compared with the huge σ numbers, the physical reproductions are the easiest part to grasp. The author ran stock PyTorch with DeepSeek's seed 953049583 on an H100 and a B300: the H100 reproduced all 57,344 preserved values of V3 bit for bit but could not reproduce V4-Flash; the B300 went the other way, reproducing 461 of V4-Flash's 469 selected rows (445 entire rows bit-for-bit, 8 partly changed by training) but nothing of V3. Adding one to the seed produced no matching rows on either machine. The author also rented a GB200 and, using Moonshot's seed 20256586, reproduced all 13 of Kimi K3's preserved rows—seed plus one, and the matches vanished. The two-way controls constrain the result together: the match depends on a specific seed and a specific layout.
The report also ran a consistency check against models with public hardware disclosures: all 24 read correctly, including the Pythia family on A100s, Llama 3.1 on H100s, and Nemotron-3 Ultra, whose technical report lists a GB200 training phase. Valuable—but it cannot be converted into "100 percent accuracy": 11 of the 24 are step-zero checkpoints, and related models are not independent. The check validates consistency with known cases, not accuracy for all models.
One alternative explanation is harder: AMD. An MI300X normally runs 304 compute units; it can be partitioned into two groups of 152 or configured to use only 148, and its random-number implementation can produce the same underlying sequences—the author confirmed on real hardware that such unusual configurations do reproduce the 148/152 layouts. Identical layouts therefore do not by themselves identify the vendor. The discriminator is a subtle difference in numerical implementation: among 377 values in V4-Flash's preserved weights where two implementation paths produce different results, 363 match NVIDIA and 0 match AMD. Between the paths the report tested, this provides the harder vendor distinction for V4-Flash ("conclusive" meaning NVIDIA rather than AMD—not "trained on Blackwell throughout"). The same test could not settle the other five models, and the author deems AMD "very unlikely"—it would require deliberately configuring an entire cluster to a Blackwell unit count, and Ant Group's public cuLA repository already contains benchmarks run on a GB300 in late March. One more layer: the MI300X is itself export-controlled for China; even if the AMD branch held, the only thing that changes is which vendor's controlled chips, not the "controlled hardware" conclusion.
4. After Initialization, How Far Does the Evidence Reach?
The method's discriminating power comes from traces left jointly by hardware attributes and software implementation. PyTorch's DistributionTemplates.h selects the thread grid from device attributes, then generates and writes random numbers by thread index and grid stride—on the standard, unmodified path the report examines, a Hopper configuration does not naturally produce the two Blackwell layouts. But it can be inferred from the source that software can change grid selection and index mapping, and CUDA thread blocks can be scheduled in batches across a limited number of SMs. So this fingerprint cannot be written as a physically unfakeable hardware signature; its attributive force rests on the specific implementation and the routine initialization path.
Even accepting Blackwell initialization, the model's subsequent training history is not thereby revealed. Weights can be generated on system A and moved to system B for training; an existing checkpoint can continue training on another class of device. If NVIDIA hardware did the initializing and Ascend chips later joined the compute, the surviving initialization trace does not necessarily reveal the latter; conversely, a Hopper fingerprint does not rule out later training on Blackwell. Kimi K3's evidence is that "at least 64 separately seeded processes each left the same 152-SM layout"—which strengthens the consistency of the initialization layout, cannot be converted into 64 GPUs, and says nothing about the full training cluster's size.
Location and channel are another layer. A string of numbers in the weights carries no data-center address and no purchase contract. In the report's words: "The weights also cannot reveal who owned the chips or where they were located," and "by itself, it does not establish that chips were smuggled into China or that an export-control violation occurred." Channels outside China plainly exist: the report notes Blackwell systems can be rented from data centers outside China; the concrete precedent is Megaspeed—NVIDIA's October 2025 statement said it "is running a small commercial cloud, like many other companies throughout the world, as allowed by U.S. export control rules" abroad; in the same period Singapore police had opened a case, and, as The New York Times reported at the time, the U.S. Commerce Department was investigating too. The evidence lands in a middle state: access to controlled hardware now has technical evidence; how, and where, remains unknown. At least three explanations remain open—rental abroad under current rules, smuggling into China, other unidentified channels. The report does not pick one; neither does this article.
5. From Weights to Ten Thousand GPUs—Through How Many Assumptions?
The report also tries to estimate how much Blackwell lies behind these models. The first assumption goes up front, in the report's own words: "assuming each model was trained on the hardware that initialized it." Accept that, and the arithmetic is simple—GPU count ≈ total training compute ÷ (effective per-GPU throughput × training time). Total compute is estimated from active parameters, training tokens, and attention overhead; effective throughput is mostly taken at 20 percent of peak (25 percent for DeepSeek, which reported 39 percent for its previous model); durations are inferred from release timelines; H100 equivalents convert at NVIDIA's published peaks—a B200/B300 ≈ 2.3, a GB200/GB300 ≈ 2.5.
| Model | H100 equivalents | Blackwell, best estimate | Range | Assumed run |
|---|---|---|---|---|
| V4-Flash | 3,500 | 1,500 | 250–5,000 | 50 days |
| V4-Pro | 7,500 | 3,000 | 750–6,500 | 70 days |
| Kimi K3 | 11,500 | 4,500 | 1,000–9,500 | 70 days |
| M3 | 3,500 | 1,500 | 200–7,000 | 60 days |
| Ling-3.1-flash | 4,000 | 1,500 | 400–6,500 | 100 days |
| Sum of runs | ~30,000 | ~12,000 | 7,000–22,000 | — |
Under these assumptions, the largest single run is Kimi K3 at a central estimate of about 4,500 GPUs. The five runs' configured estimates add to about 12,000—a figure to read carefully: the same GPUs can be reused across time and tasks, and without start-and-end dates or resource-sharing information, the sum cannot be read as "the four labs together own 12,000 Blackwells." The 7,000–22,000 range is the author's own aggregate, not the per-row bounds summed; how it was aggregated is not shown in the report. The formula is sensitive to its inputs: halve the duration and the GPU count doubles; overestimate efficiency and the count is underestimated; overestimate tokens and it goes the other way. And these inputs are precisely what a fingerprint cannot answer—DeepSeek's token counts are the lab's own, the other three labs' are the author's estimates from an unpublished method, and no run's actual efficiency or duration has been directly confirmed. Two public cases show how widely the same hardware generation varies: Mistral Large 4 used 3,800 Grace Blackwell GPUs; Microsoft's MAI-Base-2 used 16,000 over 38 days.
The money conversion goes a step further. The report cites a Wall Street Journal deal—about 36,000 Blackwell chips, more than $2.5 billion—averaging roughly $70,000 per GPU, then scales the largest single run to $200–300 million. Note that an averaged deal value may include whole systems, interconnect, or other costs; it is not a bare-chip price, and it implies nothing about what the labs actually paid.
These estimates were revised the day of publication: the first version assumed NVIDIA's benchmark efficiency and gave 2,000–3,000 GPUs and $150–200 million for the largest run; a same-day revision note said disclosed Blackwell runs have been less efficient, and the numbers went up. The report's own verdict on this layer, verbatim: "We are not confident in these estimates." Weight matching can be very strong while cluster size remains very uncertain—the two rest on different evidence, and neither can borrow the other's certainty.
6. Another History Inside the Open Weights
Beyond hardware attribution, the report demonstrates another possibility: tracing a model's own engineering history from its weights. Moonshot's K2.7-Code has 254 preserved rows in a stable 80/20 blend—about 80 percent inheriting K2.5's Hopper-layout values, about 20 percent a fresh draw matching the 148-SM layout, with the same blend in every row. The author reads this as a "merged checkpoint rather than mixed hardware." The thread extends the question from "where were the initial values generated" to "how one model inherits and combines another."
But the weights are often silent. Closed models offer nothing to read. Baidu's ERNIE-5.5, trained with PaddlePaddle, gave up its seed (2760) but no hardware layout. Some Qwen models were initialized on CPUs, leaving no GPU fingerprint. Meituan's LongCat-2.0 and DeepSeek's V4.1-Flash both went undetected by the search (LongCat's model card says it was trained "entirely on AI ASIC superpods," and a since-deleted fine-tuning configuration points to Ascend 910). These results only say the method read no signal; they cannot prove a given chip never participated, nor answer why initialization practices changed.
V4.1-Flash deserves its own look, and a timeline makes it clearer. In June 2025 a DeepSeek engineer wrote on GitHub, "we don't have SM100 GPUs" (SM100 is Blackwell). From April 2026, the V4 series' initialization fingerprints read as Blackwell. DeepSeek's public DeepInfer lists exactly two supported targets—NVIDIA SM100 and Ascend 950—with its published benchmarks run on SM100 (we covered this in our DeepInfer deep dive; Gregory Maxwell made the same point on Hacker News). And the model DeepInfer currently supports is V4.1-Flash—precisely the model this report could not read. Both facts can hold at once: what hardware an inference engine supports, and whether a model's final weights retain a recognizable initialization structure, are different questions.
In my view, the value of this work is that it turns a piece of initialization history previously dependent on lab disclosure into a question anyone can test against the weights. It proposes an explicit generation mechanism and supplies hold-out checks, wrong-seed controls, cross-hardware reproduction, and alternative-implementation checks—each with a concrete object others can re-examine. Publishing partial verification material is still a distance from an independently reproduced research chain; the next advances will come from independent researchers—whether the same results fall out of the raw weights, which conclusions hold only under particular versions or settings, and whether alternative explanations remain unexcluded.
The debate over compute thus gains a class of material anyone can check: the models' own weights. Those nearly untouched initial numbers may preserve a stretch of engineering history. Explain as much as can be read, no more; leave the rest to future evidence—and to three things worth watching: whether the named labs respond, rebut, or sue; whether PyTorch/cuRAND upstream changes its default layout behavior (DistributionTemplates.h), since the forensics window begins to close the moment the implementation details it depends on change; and whether export-control enforcement (entity-list pace, rules on overseas rental) tightens because of this report—that is the other storyline, where the Jensen Huang case and the Megaspeed timeline live. This article does not pull that storyline in; it only points to the join.
Related reading: DeepInfer Deep Dive: How DeepSeek Designs Model, Cache, and Scheduling into a Token Factory | Two Cracks in the Export Control Wall: Apple Courts CXMT, GLM-5.2 Rivals Mythos | AI Compute Demand Trends: November 2026
Sources: Will DePue, "Top Chinese Frontier AI Models Carry the Fingerprint of Export-Controlled NVIDIA Blackwell GPUs" (Unemployment Labs, published Nov 12, 2026; this article uses the version consulted Nov 13); public verification repository github.com/macrogrants/checkpoint-forensics (Nov 13, 2026); Hacker News discussion (item 50474883); CNBC, Oct 10, 2025 (NVIDIA statement); NYT, Oct 9, 2025 (Commerce probe, via CNBC); WSJ, March 2026 (unit price, as cited in the report); PyTorch DistributionTemplates.h (github.com/pytorch/pytorch); model weights and technical reports per the original report's Sources section.
