AI-Driven Wireless & ML

RemoteRF streams complex baseband IQ samples over the network between remote software-defined radios and Python AI/ML frameworks, allowing you to train, fine-tune, and evaluate models directly on your workstation or GPU server.

Decoupling GPU Compute from Radio Hardware

Because the remoterf client requires only Python 3.10+ and network access, you can install it directly in a virtual environment, container, or GPU server without installing local SDR drivers:

  • Run directly on GPU servers & clusters: Install remoterf in any Python environment on a workstation, container, or GPU server without attaching USB radios or installing hardware drivers.
  • Real hardware and channel effects: Streaming waveforms through physical transceivers exposes models to real hardware impairments, synchronization offsets, and over-the-air propagation effects that synthetic channel models miss.
  • Cross-device & multi-site evaluation: Test how well a model generalizes across different physical transmitters, receivers, and environments by switching reservation tokens across SDR handles or deployments.
All model training, inference, and signal processing run locally on the user’s machine (CPU/GPU), while the RemoteRF deployment handles over-the-air data collection.

ML Wireless Research Areas

Learned Transceivers & Signal Processing

Train and evaluate data-driven receivers, channel estimators, demappers, or end-to-end transceivers using IQ samples captured over cabled or over-the-air SDR links.

Closed-Loop Reinforcement Learning

Wrap reserved SDRs in an environment loop where an agent updates radio parameters (such as frequency, gain, or waveform settings) and observes real-time link metrics from live captures.

RF Fingerprinting & Device Identification

Transmit waveforms from multiple physical SDRs into a shared receiver to study hardware-specific emitter characteristics and evaluate generalization across devices and sessions.

Site-Specific Wireless Techniques

Develop and evaluate models tailored to the propagation and interference characteristics of a specific environment, or test generalization across different RemoteRF deployments.

Spectrum Sensing & Classification

Collect labeled IQ captures across different SNR levels, sample rates, and signal types to train and benchmark classification, detection, or foundation models.

Training & Evaluation Patterns

Researchers typically connect RemoteRF to AI/ML pipelines in three ways:

  • Offline Dataset Collection & Benchmarking: Run automated Python sweeps across frequencies, gains, waveforms, or multiple physical radios to log labeled IQ datasets for offline training and reproducible evaluation.
  • Sim-to-Real & Site-Specific Fine-Tuning: Pre-train a model offline on simulated channels, then stream live over-the-air captures from a deployment to adapt the model to real hardware impairments and site-specific channels.
  • Online & Closed-Loop Learning: Place radio .tx() and .rx() calls directly inside a live training or evaluation loop so a model or agent can update waveform parameters, beam weights, or power allocation in real time.

PyTorch + RemoteRF Example

The example below runs a PyTorch evaluation sweep across transmit gain levels on a reserved radio:

import numpy as np
import torch
from remoterf.drivers.adalm_pluto import adi

TOKEN = "Pluto_00@ucla"
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

# Connect to a reserved remote radio
sdr = adi.Pluto(token=TOKEN)

sdr.sample_rate = int(2e6)
sdr.tx_lo = int(915e6)
sdr.rx_lo = int(915e6)
sdr.tx_cyclic_buffer = True
sdr.gain_control_mode_chan0 = "manual"
sdr.rx_hardwaregain_chan0 = 30
sdr.rx_buffer_size = 8192

tx_frame = ...  # complex baseband frame
rx_model = ...  # PyTorch model on GPU/CPU

# Sweep transmit gain to evaluate a deep learning model across SNR levels
for tx_gain_db in [-30, -25, -20, -15, -10]:
    sdr.tx_hardwaregain_chan0 = tx_gain_db

    sdr.tx_destroy_buffer()
    sdr.tx(tx_frame.astype(np.complex64))

    # Clear receive buffer and capture live IQ samples
    sdr.rx_destroy_buffer()
    rx_iq = sdr.rx().astype(np.complex64)

    # Move complex IQ to GPU as a [1, 2, N] (I/Q) tensor
    iq_tensor = torch.stack([
        torch.from_numpy(rx_iq.real),
        torch.from_numpy(rx_iq.imag),
    ], dim=0).unsqueeze(0).to(device)

    with torch.no_grad():
        llr_pred = rx_model(iq_tensor)

sdr.tx_destroy_buffer()
sdr.rx_destroy_buffer()

Next Steps