Supercharging Channel Estimation with NVIDIA’s Aerial Framework: From Classic DSP to Real-Time ML

Image courtesy of NVIDIA Open Sources Aerial Software to Accelerate AI-Native 6G | NVIDIA Blog

The Story: From Theory to Real-Time Innovation

Wireless channel estimation is the unsung hero behind every smooth video call, every blazing-fast download, and every reliable 5G connection. But as wireless environments get more complex, classic algorithms sometimes struggle to keep up. What if you could combine the best of traditional signal processing with the power of machine learning — without reinventing the wheel?

That’s where NVIDIA’s open source Aerial Framework comes in. With its modular, GPU-native design, Aerial lets you focus on your algorithm, not the plumbing. You can leverage robust, pre-built modules by simply including their headers and deriving your own classes — abstracting away the low-level details and letting you innovate at the speed of thought.

In my previous articles, I have given an overall view of Aerial and the frameworks therein with a little overview of how to use them.

This Medium article builds on prior pieces introducing the Aerial Framework as an orchestration layer over cuRAN’s CUDA kernels and a 5G NR channel estimation pipeline using LS and interpolation. Here, the focus shifts to integrating AI/ML models via TensorRT for superior channel estimation performance in 5G NR systems.

Why AI/ML for Channel Estimation?

Traditional LS estimation computes Ĥ[k] = Y[k]/X[k] at pilots but amplifies noise without correlation awareness. Linear interpolation fills data subcarriers but struggles with fast-fading channels. AI/ML models, trained on (received pilots, true channels), learn complex patterns like multipath and Doppler, achieving lower MSE (e.g., 0.061 vs 0.089 for LS).​

Neural networks — CNNs or transformers — map sparse pilots to full-grid estimates, outperforming MMSE in non-linear scenarios. NVIDIA Aerial’s cuPHY supports TensorRT engines, enabling <0.35ms inference on GPUs for real-time PUSCH/PDSCH processing.

Leveraging the Aerial Framework: Plug-and-Play Research

Aerial provides a set of C++ interfaces and CUDA-accelerated modules for wireless signal processing. Here’s how easy it is to build on top of the framework:

// channel_estimation_module.hpp
#include "channel_estimation_module.hpp"

// Use the provided ChannelEstimator or derive your own
class MyCustomEstimator : public channel_estimation::IChannelEstimator {
public:
    void setup_memory(const framework::pipeline::ModuleMemorySlice& memory_slice) override { /* ... */ }
    void warmup(cudaStream_t stream) override { /* ... */ }
    void configure_io(const framework::pipeline::DynamicParams& params, cudaStream_t stream) override { /* ... */ }
    // ...implement other required methods...
};

The framework provides a clean interface for plugging in your estimator, whether it’s classic DSP or ML-based.

Classic Channel Estimation: Aerial’s CUDA-Accelerated Kernels

Aerial’s built-in estimators use highly optimized CUDA kernels. For example, the classic Least Squares (LS) estimator is implemented as:

// channel_estimation_module.cu
__global__ void ls_channel_estimation_kernel(const cuComplex* rx_pilots, const cuComplex* tx_pilots, cuComplex* channel_estimates, int num_pilots) {
    int idx = blockIdx.x * blockDim.x + threadIdx.x;
    if (idx < num_pilots) {
        // LS estimate: H = Y / X
        cuComplex y = rx_pilots[idx];
        cuComplex x = tx_pilots[idx];
        channel_estimates[idx] = cuCdivf(y, x);
    }
}

You can invoke this kernel from your estimator’s execute() method, and the framework handles device memory and stream management for you.

Training a Machine Learning Model for Channel Estimation

The ML pipeline starts with data: pairs of received pilot signals and their true channel responses. My Git repo includes a ready-to-use script, generate_channel_estimation_model.py, which generates synthetic data and trains a neural network:

# generate_channel_estimation_model.py
class ChannelEstimationNet(nn.Module):
    def __init__(self, num_antennas, num_users):
        super().__init__()
        self.network = nn.Sequential(
            nn.Linear(num_users * num_antennas * 2 + 1, 512),
            nn.BatchNorm1d(512),
            nn.ReLU(),
            nn.Linear(512, 256),
            nn.ReLU(),
            nn.Linear(256, num_users * num_antennas * 2),
            nn.Tanh()
        )
    def forward(self, x):
        return self.network(x)

# Training loop (simplified)
for epoch in range(epochs):
    for xb, yb in loader:
        optimizer.zero_grad()
        pred = net(xb)
        loss = loss_fn(pred, yb)
        loss.backward()
        optimizer.step()

After training, export the model to ONNX and then to TensorRT for GPU inference:

torch.onnx.export(net, dummy_input, "model.onnx")
# Then on the command line:
# trtexec --onnx=model.onnx --saveEngine=model.engine --fp16

Integrating ML into the Aerial Pipeline

With your model ready, using it in the Aerial channel estimation pipeline is as simple as:

#include "ml_channel_estimator_tensorrt.hpp"

channel_estimation::ChannelEstParams params;
params.algorithm = channel_estimation::ChannelEstAlgorithm::ML_TENSORRT;
params.model_path = "./model.engine";
params.ml_input_size = 128;
params.ml_output_size = 256;

auto estimator = std::make_unique<channel_estimation::MLChannelEstimatorTRT>("ml_estimator", params);

Or, from the command line:

./channel_estimation_example --algorithm ml_tensorrt --model_path ./model.engine --ml_input_size 128 --ml_output_size 256

The framework handles device memory, stream management, and even falls back to classic algorithms if the ML model isn’t available.

Output which is worth it

# channel_estimation_example
Creating channel estimation pipeline...
Pipeline ID: test_channel_estimation
Setting up pipeline...
[DEBUG] Allocated: d_params_=0x7f755c800200 d_pilot_estimates_=0x7f755c800800
Warming up pipeline...
Generating test data...
Number of pilots: 75
Number of subcarriers: 300
[DEBUG] Example device ptrs: d_rx_pilots=0x7f755c809000, d_tx_pilots=0x7f755c809400, d_channel_estimates=0x7f755c809800
[DEBUG] Pipeline: set_inputs called with all_ports. Now calling configure_io...
Channel estimation pipeline executed successfully!
First 5 channel estimates:
  [0]: (0.706574, 0.372196)
  [1]: (0.757888, 0.338698)
  [2]: (0.809201, 0.305201)
  [3]: (0.860515, 0.271703)
  [4]: (0.911829, 0.238206)
Test completed successfully!

Why Aerial? Open Source, GPU-Native, Researcher-Friendly

NVIDIA’s Aerial Framework is open source and designed for wireless research at scale. It abstracts away the boilerplate, letting you:

• Focus on algorithms, not infrastructure
• Seamlessly switch between DSP and ML approaches
• Run everything on the GPU for real-time performance

Call to Action: Experiment, Extend, and Share

Ready to try your own ideas? Clone the repo, train a model, and drop it into the pipeline. Experiment with different neural architectures, pilot patterns, or even hybrid DSP+ML approaches. The Aerial Framework makes it easy to benchmark, iterate, and share your results.

Armed with this blueprint, 6G researchers and PHY engineers — imagine what happens when you swap LS for your custom transformer trained on terahertz channels, or chain ML estimation directly into neural beamforming for end-to-end learning. The Aerial Framework unlocks GPU-scale AI that turns research prototypes into production DU pipelines overnight, but these are just the opening moves in the AI-RAN revolution.

Wireless innovation is just a header include away. What will you build next?

References

• My GitHub repo: samuel-sujith/nvidia-aerial-examples
• NVIDIA Aerial Framework (Open Source): https://github.com/NVIDIA/aerial
• NVIDIA Aerial Documentation: https://developer.nvidia.com/aerial
• TensorRT Documentation: https://docs.nvidia.com/deeplearning/tensorrt/
• PyTorch Documentation: https://pytorch.org/docs/stable/index.html
• NVIDIA Aerial: AI/ML Components for PUSCH Channel Estimation​
• Sionna Documentation​
• Channel Estimation for PUSCH Notebook​
• PUSCH Channel Estimation Tutorial​
• pyAerial Data Lake Channel Estimation​
• Deep Learning Data Synthesis for 5G Channel Estimation (MathWorks)​
• AI Driving Innovation in Wireless (5G Americas)