从随机接入到智能连接：基于学习的稀疏恢复用于联合活动...

从随机接入到智能连接：基于学习的稀疏恢复，用于大规模无线网络中的联合活动检测和信道估计

无线通信新范式的描述：基于学习的稀疏恢复，用于大规模随机接入系统中的联合活动检测和信道估计

介绍：

物联网（IoT）的蓬勃发展为无线网络带来了一个新的挑战：大规模随机接入。想象一下，成千上万的设备，从智能传感器到智能电表，都在零星地尝试与中央基站通信。传统的无线接入协议依赖于设备请求专用信道，在这种情况下效率低下，导致高延迟和信令开销。

这个问题可以被定义为一个稀疏恢复挑战。在任何给定的时刻，只有一小部分设备是活跃的。我们可以将基站接收到的信号建模为一个更大的稀疏信号的压缩版本。这个稀疏信号的非零元素代表活跃设备，它们的值对应于估计的信道状态信息（CSI）。因此，联合活动检测（AD）和信道估计（CE）的任务等同于一个稀疏信号恢复问题。

从传统方法到基于学习的方法的演变

传统上，这种应用的稀疏恢复依赖于诸如正交匹配追踪（OMP）、基追踪（BP）和近似消息传递（AMP）之类的算法。虽然有效，但这些方法通常面临局限性。它们可能在计算上是密集型的，并且它们的性能高度依赖于关于信道和噪声模型的理想假设。🧠

这就是基于学习的方法大放异彩的地方。通过利用数据科学和机器学习的力量，我们可以设计算法来直接从训练数据中学习恢复稀疏信号。这些方法通常基于深度神经网络，可以学习到传统算法无法学习的复杂的非线性关系。它们还可以针对特定的性能指标进行优化，并且对于诸如不完善的信道知识和非理想的噪声之类的真实世界的损伤更加鲁棒。

一种特别有前途的技术是使用基于模型的深度学习。这种方法将迭代稀疏恢复算法（如AMP或迭代软阈值算法（ISTA））“展开”到神经网络的层中。网络的每一层对应于算法的一次迭代，并且关键参数（例如，阈值函数）在训练过程中被学习。这结合了传统算法的可解释性和理论保证与神经网络的强大学习能力。

数据科学程序：一个简化的 Python 实现

Python 程序，它说明了基于学习的稀疏恢复用于联合活动检测和信道估计的核心概念。本例使用一个基本的神经网络来学习一个阈值函数，它是像 ISTA 这样的稀疏恢复算法的关键组成部分。

先决条件

这些库：numpy、torch (PyTorch)、scikit-learn 和 matplotlib。

import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt
## --- 1. System Model and Data Generation ---
## This function simulates the wireless communication system.
## It creates a sparse channel vector and generates received signals.
def generate_data(num_devices, num_antennas, num_samples, sparsity):
    """
    Generates synthetic data for massive random access.

    Args:
        num_devices (int): Total number of potential devices.
        num_antennas (int): Number of antennas at the base station.
        num_samples (int): Number of data samples to generate.
        sparsity (float): The fraction of active devices.

    Returns:
        tuple: A tuple containing the received signals (y) and the true channel vectors (x).
    """
    active_users = int(num_devices * sparsity)
    # The sensing matrix (A) is the pilot matrix
    A = np.random.randn(num_antennas, num_devices) / np.sqrt(num_antennas)
    all_x = []
    all_y = []
    for _ in range(num_samples):
        # Generate a sparse vector x (channel coefficients)
        x = np.zeros(num_devices)
        active_indices = np.random.choice(num_devices, active_users, replace=False)
        x[active_indices] = np.random.randn(active_users) + 1j * np.random.randn(active_users)
        # Simulate received signal y = Ax + n (noise)
        noise = np.random.randn(num_antennas) * 0.1 + 1j * np.random.randn(num_antennas) * 0.1
        y = A @ x + noise
        all_x.append(x)
        all_y.append(y)
    return np.array(all_y), np.array(all_x), A
## --- 2. Learning-Based Sparse Recovery Model ---
## This is a simple deep neural network that learns the sparse recovery task.
class SparseRecoveryNet(nn.Module):
    def __init__(self, num_devices, num_antennas, num_layers=5):
        super(SparseRecoveryNet, self).__init__()
        # Learnable parameters for the ISTA-like layers
        self.theta = nn.Parameter(torch.tensor(0.1, requires_grad=True)) # Threshold parameter
        self.gamma = nn.Parameter(torch.tensor(0.1, requires_grad=True)) # Step size
        self.num_layers = num_layers
        self.A_T = None # Transpose of sensing matrix A
    def forward(self, y, A):
        self.A_T = A.t()
        # Initialize the estimate s
        s = torch.zeros_like(y[:, 0])
        for _ in range(self.num_layers):
            # Gradient descent step
            r = s + self.gamma * (self.A_T @ (y - A @ s))
            # Learnable soft-thresholding function for sparsity
            # This is the core 'learning' part
            s = torch.where(torch.abs(r) > self.theta, r - self.theta * torch.sign(r), torch.tensor(0.0, device=r.device))
        return s
## --- 3. Main Program ---
if __name__ == "__main__":
    # Parameters
    num_devices = 100
    num_antennas = 50
    num_samples = 2000
    sparsity = 0.05 # 5% of devices are active
    # Generate data
    y_raw, x_raw, A_np = generate_data(num_devices, num_antennas, num_samples, sparsity)
    # Split data into training and testing sets
    y_train_np, y_test_np, x_train_np, x_test_np = train_test_split(y_raw, x_raw, test_size=0.2, random_state=42)
    # Convert to PyTorch tensors
    A_torch = torch.from_numpy(A_np.astype(np.float32))
    y_train = torch.from_numpy(y_train_np.astype(np.float32))
    x_train = torch.from_numpy(x_train_np.astype(np.float32))
    y_test = torch.from_numpy(y_test_np.astype(np.float32))
    x_test = torch.from_numpy(x_test_np.astype(np.float32))
    # Initialize the model, loss function, and optimizer
    model = SparseRecoveryNet(num_devices, num_antennas)
    criterion = nn.MSELoss()
    optimizer = optim.Adam(model.parameters(), lr=0.01)
    # Training Loop
    num_epochs = 100
    train_losses = []
    print("Starting training...")
    for epoch in range(num_epochs):
        model.train()
        optimizer.zero_grad()
        # Forward pass
        x_pred = model(y_train, A_torch)
        # Reshape for loss calculation
        loss = criterion(x_pred.abs(), x_train.abs()) # We'll use the magnitude for simplicity
        # Backward pass and optimization
        loss.backward()
        optimizer.step()
        train_losses.append(loss.item())
        if (epoch+1) % 10 == 0:
            print(f"Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}")
    print("Training finished.")
    # Evaluation
    model.eval()
    with torch.no_grad():
        x_test_pred = model(y_test, A_torch)
        test_loss = criterion(x_test_pred.abs(), x_test.abs())
        # Calculate Active Device Detection Accuracy
        # Compare the support of the predicted and true sparse vectors
        true_support = x_test.abs().sum(dim=1) > 1e-3
        pred_support = x_test_pred.abs().sum(dim=1) > 1e-3
        accuracy = (true_support == pred_support).sum().item() / len(true_support)
    print(f"\nTest Mean Squared Error: {test_loss.item():.4f}")
    print(f"Test Activity Detection Accuracy: {accuracy*100:.2f}%")
    # Plotting the training loss
    plt.figure(figsize=(10, 6))
    plt.plot(range(num_epochs), train_losses, label='Training Loss')
    plt.title('Training Loss over Epochs')
    plt.xlabel('Epoch')
    plt.ylabel('MSE Loss')
    plt.legend()
    plt.grid(True)
    plt.show()

结论：

稀疏恢复理论与深度学习的融合对于大规模随机接入系统来说是一个变革性的步骤。通过训练一个神经网络来执行活动检测和信道估计的联合任务，我们可以克服传统的、模型驱动的方法的局限性。基于学习的方法提供了卓越的性能、对现实世界条件的增强的鲁棒性以及显著降低所需信令开销的潜力。随着连接设备数量的持续指数增长，这些智能的、数据驱动的解决方案对于构建下一代高效且可扩展的无线网络至关重要。

• 原文链接： blog.blockmagnates.com/f...
• 登链社区 AI 助手，为大家转译优秀英文文章，如有翻译不通的地方，还请包涵～