DNN Challenge 1: Modulation classification on a parameter budget

The signals are synthetic but physically realistic. A transmitter on a 5.9 GHz carrier sends one of the 8 modulations, at a random symbol rate of about 31–62 kBd and with randomised pulse shaping. The signal then passes through a realistic link:

• Fading: time-varying multipath fading (Rician or Rayleigh), from a receiver moving at up to 120 km/h.
• Receiver errors: a carrier frequency offset of up to a few frequency bins, phase noise, symbol-timing and sample-clock offsets, IQ imbalance and a DC offset.
• Noise: additive white Gaussian noise at a per-example Es/N0 drawn uniformly from −4 dB to 16 dB, so many examples are very noisy.

The receiver samples complex baseband at 250 kS/s and records 1040 samples (4.16 ms). It normalises the power to a mean of 1 and computes the spectrogram:

• STFT: 32-point Hann window, hop 16 samples, 64 frames, two-sided.
• Value: 10·log10(|X|²) in dB, stored as float16.

Each example x[i] is a 32 × 64 array of dB values.

The frequency axis is circular. FFT bins wrap around, so row 31 and row 0 are neighbours (+117.2 kHz is next to −125 kHz).

The files are uploaded on Github. See the details below.

Load the data with d = np.load("train.npz"), then use d["x"], d["y"] and so on.

The metadata fields (snr_db, sps, k_db, speed_kmh) may be used during training, if required. However, they are not available to the model at test time.

The organisers hold 24,000 test examples drawn from the same distribution as train.npz. They are never released, and the organisers run your model on them:

• Public test set (8,000 examples): scores the live leaderboard during the challenge.
• Private test set (16,000 examples): decides the final ranking.

Your network may contain only the following learnable layers. Each item may be used at most once, and unused items are fine.

Free choices for each inventory layer:

• its number of input channels or features (they follow from your wiring);
• stride, dilation, padding amount and padding mode;
• groups (grouped and depthwise convolutions are allowed);
• whether it has a bias.

The output channel count and kernel size must match the table exactly.

At most 75,000 parameters, counted as every weight and bias of the inventory layers as stored in your submitted file.

Normalisation layers (BatchNorm, LayerNorm, GroupNorm, InstanceNorm) are free, as long as their affine parameters are one value per channel or feature. There is one subtlety. When you export, a BatchNorm that directly follows a convolution is usually folded into that convolution, which then gains a bias if it had none. That bias counts. Leave a few hundred parameters of headroom, or simply give your convolutions a bias. The checker prints the exact count.

Anything without learnable parameters that keeps the network a plain feed-forward CNN is allowed:

• activations: ReLU, LeakyReLU, ELU, SELU, SiLU/Swish, GELU, Mish, sigmoid, tanh, hard-sigmoid/swish, clipping;
• pooling and statistics: max, average, global and adaptive pooling, and statistics such as mean, max, min, standard deviation or log-sum-exp over any axes;
• connections: skip or residual connections (addition or concatenation) and multiple branches;
• tensor operations: reshaping, flattening, transposing, padding (any mode), slicing, flipping, rolling and concatenating;
• regularisation: dropout;
• normalisation layers, as in §3.2;
• input transforms inside the model: fixed, deterministic preprocessing, including per-example statistics such as subtracting the example's mean.

• Extra learnable parameters or stored constant tensors of any kind outside the inventory and the per-channel normalisation parameters. This includes PReLU, learnable scales, biases or positional maps, squeeze-and-excitation blocks and lookup tables.
• Attention in any form, including parameter-free attention:
  • softmax over features or positions;
  • dot products or matrix products between two feature tensors;
  • multiplying or dividing a feature map by another feature map computed through a different layer (gating).
  • Allowed: elementwise activations of a single tensor, such as x·sigmoid(x), and normalisation by a statistic of the same tensor.
• Non-CNN layers: recurrent layers (RNN/LSTM/GRU), transformer blocks and transposed convolutions.
• Control flow, dynamic weights and weight sharing: a weight tensor may not be used by more than one layer call, and layers may not be applied repeatedly in loops.
• A softmax at the output: return raw scores (logits).

• Train only on train.npz and val.npz. You may use both in any way, including training on val.npz. No other data, real or synthetic.
• No pretrained weights. No knowledge distillation from any other model. No ensembles: the submission is one network.
  • Averaging the weights of a single training run (EMA, SWA) is fine, because the result is still one network.
• Augmentation, optimiser, schedule, loss, regularisation and framework are your choice. The only requirement is that you can export to ONNX; the template uses PyTorch.

The organisers can verify the architecture rules (§3.1–3.4) directly from the submitted file, and they do so automatically. They cannot verify the training rules (§3.5) from your model, but can do so from the final code you submit.