A wireless foundation model on 5G NR time-frequency resource grids.
Paper ·
Model & code
Loading data…
How one training slot is made. Pick an example and follow it through the eight stages of the released
generator (dataset/ in wi-lab/lwm-tf,
Sionna 2.1). The 24 examples cover 4 channel classes × 3 modulations × static/mobile. Every number and array below was
produced by that code and precomputed; nothing is simulated in your browser.
The resource grid geometry (PRBs, SCS and DMRS) is fixed per batch. DMRS uses mapping type A, configuration type 1, and
the REs of the CDM group without data stay empty. The four additional positions trade pilot overhead against time tracking.
The corpus plan is fixed before any channel is drawn. It holds exactly 250k slots per class, split evenly over the DMRS
positions, with 25% static UEs in every cell. Target SNR and modulation are drawn per slot, independently of each other and of the channel.
③
Transmit chain
transmitter.py · transmit_per_mcsTS 38.212 / 38.211, paper §II-A
TR 38.901 draws one single-sector topology per slot, with path loss and shadow fading. DeepMIMO uses ray-traced paths
with centred subcarriers, first-arrival timing and per-path Doppler u·v/λ at the OFDM symbol starts.
⑤
Noise calibration
channel.py · noise_variance_for_snrpaper §II-B
At fixed transmit power the scenarios sit tens of dB apart. Noise is therefore set from the drawn target SNR,
σ² = ḡγ g1−γ / 10ρ/10, with γ = 0 in this corpus. Then Y = H·X + W.
ILLA proposes the highest MCS whose predicted BLER stays under 0.1 at the LMMSE post-equalization SINR, after a 3 dB
backoff that stands in for outer-loop adaptation. The modulation is drawn uniformly, and the proposal is snapped into that class.
A 3GPP receiver runs on every slot to produce its labels: an LS estimate on the DMRS, LMMSE equalization, max-log
demapping, then LDPC decoding and the transport-block CRC. The encoder never sees this chain; its input is Y itself.
⑧
Normalize & store
corpus.py · receive → _flushpaper §II-D
Each slot is divided by its RMS and stored as float16, with Re/Im interleaved per port. The scale and every label go to a
separate file that only the downstream probes read.
Receive power of one PUSCH slot per Rx antenna: 14 OFDM symbols × 288 subcarriers (24 PRB), slot RMS = 0 dB.
The bundled set is 144 test-set-2 slots, 8 per scenario × modulation × mobility.
–
The released encoder sees 7 of 14 OFDM symbols and the same 48 of 96 (antenna, PRB) positions, the pre-training mask
(75% of 1,344 tokens hidden). The decoder predicts the patch-normalized log-power of every masked token, and its scale head
restores the level. It runs in your browser with ONNX Runtime; the model download is 39 MB on first use.
t-SNE of 3,000 test-set-2 slots (precomputed), for the frozen 256-d LWM-TF embedding and for seven engineered receiver
statistics.
Frozen features plus a logistic probe, fitted on K labeled slots per class.
Lines: reference curves, 10 paired draws (sklearn).
Points: your run, computed in this browser with the same objective (L-BFGS); both feature sets use the same draws.
The split is by generation batch: the labeled pool comes from one half of test set 2 and the score from the other half.
What is LWM-TF?
LWM-TF is a 9.58 M-parameter factorized masked autoencoder. It is pre-trained on complex 5G NR uplink (PUSCH) receive
grids, taken after the FFT and before channel estimation. Each block attends first across the 14 OFDM symbols, then across the 96
(antenna, PRB) positions of a symbol, and the mask follows the same two axes. The payload phase is unpredictable, so the model
reconstructs the normalized log-power of each masked token and predicts its scale separately.
Input and output
One slot is a [8, 14, 288] real tensor: Re/Im for each of 4 Rx antennas × 14 OFDM symbols × 288 subcarriers
(24 PRB at 30 kHz). Each slot is divided by its RMS. model.embedding(grid) returns a 256-d vector, the mean over
the encoder's 1,344 tokens.
from lwm_tf import load_model # huggingface.co/wi-lab/lwm-tf
model = load_model("wi-lab/lwm-tf")
z = model.embedding(grid) # [B, 8, 14, 288] float32 -> [B, 256]
This demo
Checkpoint: P0 seed 0, 200k pre-training steps on 1M slots of TR 38.901 UMa / UMi / RMa and DeepMIMO ray-traced
links. The paper reports the 40k checkpoint trained on the 3GPP-only corpus, so the numbers here are not the paper's.
Data: test set 2 of the paper. It holds 24,576 separately generated 3GPP slots: 8,192 per scenario, QPSK / 16QAM / 64QAM,
0–120 km/h and −5 to 30 dB SNR. Embeddings, receiver statistics and labels are bundled for every slot; raw grids for 144.
Probes: a demo protocol. The pool and the scored half both come from test set 2, split by generation batch;
the paper fits on a separate development bank.
Data generation: the generator is released as dataset/ in wi-lab/lwm-tf. The tab shows 24 slots traced with it
(build_pipeline_traces.py); its traced_receive is checked to equal the corpus code bit for bit.
Everything runs client-side. Nothing you do here is sent anywhere.
Citation
@article{kim2026lwmtf,
title = {{LWM-TF}: A Wireless Foundation Model on {5G NR} Time-Frequency Resource Grids},
author = {Kim, Namhyun and Alikhani, Sadjad and Alkhateeb, Ahmed},
journal = {arXiv preprint arXiv:2610.21013},
year = {2026}
}