第【50期】--基于深度学习的车联网(v2v)的信道估计方案研究--matlab+python完整代码+参考文章
·
关注我，追更更多通信仿真！
摘要：车联网（V2V）通信中的高移动性导致信道呈现时间‑频率双选择性衰落，传统基于导频或数据辅助的估计方法因导频稀疏和误差累积而性能受限。本文基于IEEE 802.11p物理层标准，设计并实现了一套完整的数据导频辅助信道估计方案，并在此基础上引入时间卷积网络（TCN）对DPA的初始估计进行深度特征重构。通过分离接收信号的实部与虚部并构建时序输入矩阵，TCN能够捕捉相邻子载波间的频域相关性，从而输出更准确的信道初始值。进而结合DPA迭代更新和时域平均（TA）后处理，形成TCN‑DPA‑TA联合估计架构。仿真在车辆‑车辆同向带墙（VTV‑SDWW）信道模型下进行，调制方式为16QAM。结果表明，所提方案在误码率（BER）和归一化均方误差（NMSE）上均优于传统LS、DPA、STA、CDP方法，，验证了TCN在信道估计任务中的优越性与鲁棒性。
文章名【A DATA PILOT-AIDED TEMPORAL CONVOLUTIONAL NETWORK
FOR CHANNEL ESTIMATION IN IEEE 802.11P
VEHICLE-TO-VEHICLE COMMUNICATIONS】
一、背景与意义
1.1 车联网通信的演进与挑战
智能交通系统（ITS）的快速发展使车辆对一切（V2X）通信成为实现安全驾驶、交通效率提升和自动驾驶协同的关键支撑。在众多候选技术中，IEEE 802.11p标准凭借其在专用短程通信（DSRC）领域的成熟部署，长期作为车联网物理层的核心规范。然而，随着应用需求从基础告警向高清地图传输、协同感知升级，系统对数据速率和可靠性的要求呈指数增长，这对物理层的基础信号处理能力提出了严苛挑战。
车联网通信最本质的物理难点在于信道的时频双选择性。车辆在高速移动（典型值100 km/h）时，多普勒频移可达数百赫兹，导致信道响应不仅在多径引起的频率轴上呈现选择性衰落，在时间轴上也剧烈变化。这种双重变化使得接收机必须在极短时间内（一个OFDM符号周期约8微秒）完成信道追踪，否则均衡、解调乃至解码将全面失效。
1.2 传统信道估计的瓶颈
现有的信道估计体系高度依赖导频信号。IEEE 802.11p在每帧开头仅提供两个长训练序列用于初始最小二乘（LS）估计，并在数据符号中嵌入4个固定导频子载波。这种设计在静态或低速场景下尚可应付，但在高动态车联网环境中，导频密度远不足以捕获信道的快速变化。为此，学术界提出数据导频辅助（DPA）方案，通过将已判决的数据符号“伪”视为导频来迭代更新信道。然而，DPA存在致命的误差传播问题——一旦某个符号判决错误，后续所有符号的估计都会偏离真实值，且错误随帧传播加速恶化。
后续的改进算法如频谱时域平均（STA）、构造数据导频（CDP）和可靠性测试插值（TRFI），虽引入了频域平滑、时域滤波或双重校验机制，但它们本质上是基于固定模式的线性处理，无法自适应信道的动态变化，在极端多普勒下性能提升有限。
1.3 深度学习契机
近年来，深度学习在物理层信号处理中展现出强大潜力。长短期记忆网络（LSTM）已被用于时序信道预测，但存在训练慢、梯度不稳定等缺陷。时间卷积网络（TCN）作为替代方案，结合因果卷积、膨胀卷积和残差连接，不仅能高效并行处理时序数据，还具有更大的感受野和更稳定的收敛特性。本文将TCN嵌入到经典的DPA框架中，用数据驱动的非线性映射替代传统的人工规则，旨在从根源上改善初始估计质量并抑制误差累积，为车联网信道估计提供一种可工程化的智能解决方案。
2 理论基础
2.1 IEEE 802.11p OFDM参数
2.2 传统信道估计方法回顾
2.2.1 最小二乘（LS）估计
2.2.2 数据导频辅助（DPA）估计
2.2.3 频谱时域平均（STA）
2.2.4 构造数据导频（CDP)
CDP利用当前DPA估计和前一CDP估计分别对前一符号进行两次均衡，若两次判决结果一致则采纳当前估计，否则沿用前一估计。该可靠性测试可部分阻止错误更新，但未能完全消除误差，且需要额外计算。
2.2.5 基于可靠性测试的频域插值（TRFI）
TRFI在CDP的基础上进一步区分“可靠”和“不可靠”子载波，仅对可靠子载波使用DPA估计，不可靠子载波则通过样条插值从可靠子载波中重构。该方法在高SNR下性能优良，但插值精度依赖可靠子载波的数量和分布，在深衰落时效果受限。
3. 基于时间卷积网络的TCN‑DPA‑TA估计方案
3.1 为什么选择时间卷积网络（TCN）？
相比循环神经网络（RNN/LSTM），TCN具有以下显著优势：
- 并行计算：卷积操作可并行执行，训练和推理速度远超RNN。
- 可控的感受野：通过膨胀卷积，TCN可以指数级扩大感受野，轻松捕捉相距几十个子载波之间的频域相关性，而不增加过多参数量。
- 稳定的梯度：借助残差连接，TCN有效规避了梯度消失问题，允许堆叠更深层的网络。
将子载波索引视为“时间步长”，利用TCN对频域序列进行建模。这背后的物理直觉是：相邻子载波上的信道响应具有强相关性，而TCN正是提取局部连续特征的高手。
3.2 数据集预处理
3.3 TCN-DPA-TA估计流程
4 仿真分析
仿真生成18,000个独立的信道实现，其中75%用于训练，12.5%用于验证，12.5%用于测试。测试信噪比覆盖0 dB至40 dB区间。为了公平对比，所有传统算法（LS、DPA、STA、CDP、TRFI）均在同一套数据集和信道模型下运行。
4.1 超参数
| 超参数 | 搜索范围 | 最优值 |
|---|---|---|
| 学习率（Learning Rate） | 1×10⁻⁵ ~ 1×10⁻² | 0.003 |
| 网络层数（Number of Layers） | 1 ~ 5 | 4 |
| 卷积核大小（Kernel Size） | 2 ~ 5 | 2 |
| Dropout 率 | 10⁻⁵ ~ 0.5 | 0.01 |
| StepLR 步长 | 10 ~ 50 | 17 |
| StepLR 衰减率（Gamma） | 0.5 ~ 1 | 0.8 |
| 训练轮数（Epochs） | 0 ~ 200 | 100（早停） |
 |
4.2 仿真结果
4.2.1 误码率（BER）性能对比
仿真结果显示：
- 低信噪比（≤10 dB）：噪声主导，所有方案BER曲线接近，但TCN-DPA-TA因TA平滑略有优势。
- 中高信噪比（≥15 dB）：TCN-DPA-PA开始显著超越传统方法。在30 dB时，其BER降至STA和CDP的约1/5；在40 dB时，TCN-DPA的BER相比传统方法降低了1个数量级。这充分证明联合架构在极端动态下的优越性。
与LSTM-MLP对比，TCN在相同训练条件下取得更低BER，归因于卷积结构更擅长提取频域局部特征，而RNN更适合长时依赖，但信道估计本质上更依赖频域相关性。
4.2.2 归一化均方误差（NMSE）表现
NMSE反映信道重构精度。仿真观察到：
- TCN-DPA-TA从 15 dB 起即全面领先所有传统算法，表明其低SNR下已具备良好的泛化能力。
- 在40 dB时，TCN-DPA-TA的NMSE比TRFI低约一个数量级。
部分代码：
import torch
import torch.nn as nn
from torch.nn import init
import torch.utils.data as data
import torch.optim as optim
import numpy as np
import scipy.io
import sys
import os
import time
from scipy.io import loadmat
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
# ======================== 模型定义 ============================
class Chomp1d(nn.Module):
def __init__(self, chomp_size):
super(Chomp1d, self).__init__()
self.chomp_size = chomp_size
def forward(self, x):
return x[:, :, :-self.chomp_size].contiguous()
class TemporalBlock(nn.Module):
def __init__(self, n_inputs, n_outputs, kernel_size, stride, dilation, padding, dropout=0.01):
super(TemporalBlock, self).__init__()
self.conv1 = nn.Conv1d(n_inputs, n_outputs, kernel_size, stride=stride, padding=padding, dilation=dilation)
self.chomp1 = Chomp1d(padding)
self.relu1 = nn.ReLU()
self.dropout1 = nn.Dropout(dropout)
self.conv2 = nn.Conv1d(n_outputs, n_outputs, kernel_size, stride=stride, padding=padding, dilation=dilation)
self.chomp2 = Chomp1d(padding)
self.relu2 = nn.ReLU()
self.dropout2 = nn.Dropout(dropout)
self.net = nn.Sequential(self.conv1, self.chomp1, self.relu1, self.dropout1,
self.conv2, self.chomp2, self.relu2, self.dropout2)
self.downsample = nn.Conv1d(n_inputs, n_outputs, 1) if n_inputs != n_outputs else None
self.relu = nn.ReLU()
self.init_weights()
def init_weights(self):
init.xavier_uniform_(self.conv1.weight)
init.zeros_(self.conv1.bias)
init.xavier_uniform_(self.conv2.weight)
init.zeros_(self.conv2.bias)
if self.downsample is not None:
init.xavier_uniform_(self.downsample.weight)
init.zeros_(self.downsample.bias)
def forward(self, x):
out = self.net(x)
res = x if self.downsample is None else self.downsample(x)
return out + res
class TemporalConvNet(nn.Module):
def __init__(self, num_inputs, num_channels, kernel_size=8, dropout=0.01):
super(TemporalConvNet, self).__init__()
layers = []
num_levels = len(num_channels)
for i in range(num_levels):
dilation_size = 2 ** i
in_channels = num_inputs if i == 0 else num_channels[i-1]
out_channels = num_channels[i]
layers += [TemporalBlock(in_channels, out_channels, kernel_size, stride=1, dilation=dilation_size,
padding=(kernel_size-1)*dilation_size, dropout=dropout)]
self.network = nn.Sequential(*layers)
def forward(self, x):
return self.network(x)
# 带自适应池化的完整模型（输出48个子载波）
class TCNWithAdaptive(nn.Module):
def __init__(self, in_channels, hidden_channels, out_channels, target_length, kernel_size=8, dropout=0.01):
super().__init__()
self.tcn = TemporalConvNet(in_channels, hidden_channels, kernel_size, dropout)
self.final_conv = nn.Conv1d(hidden_channels[-1], out_channels, kernel_size=1)
self.adaptive_pool = nn.AdaptiveAvgPool1d(target_length)
def forward(self, x):
out = self.tcn(x)
out = self.final_conv(out)
out = self.adaptive_pool(out)
return out
# ==================== 16QAM 格雷码星座点（与 MATLAB qammod 完全一致） ====================
# MATLAB: qammod(0:15, 16, 'UnitAveragePower', true) 生成的星座顺序为：
# 0:-3-3j, 1:-3-1j, 2:-3+3j, 3:-3+1j,
# 4:-1-3j, 5:-1-1j, 6:-1+3j, 7:-1+1j,
# 8: 3-3j, 9: 3-1j, 10:3+3j, 11:3+1j,
# 12:1-3j, 13:1-1j, 14:1+3j, 15:1+1j
QAM16_CONST = np.array([
-3-3j, -3-1j, -3+3j, -3+1j,
-1-3j, -1-1j, -1+3j, -1+1j,
3-3j, 3-1j, 3+3j, 3+1j,
1-3j, 1-1j, 1+3j, 1+1j
]) / np.sqrt(10)
def demap_16qam(y):
"""硬判决：返回距离最近的星座点（复数），与 MATLAB qamdemod 一致"""
y = np.asarray(y)
if y.ndim == 0:
y = np.array([y])
dist = np.abs(y[:, None] - QAM16_CONST[None, :])
idx = np.argmin(dist, axis=1)
return QAM16_CONST[idx] # 直接返回复数星座点
def map_16qam(idx):
"""根据整数索引返回星座点（用于 DPA 迭代中的 q）"""
return QAM16_CONST[idx.astype(int)]
# ======================== 主程序 ============================
if __name__ == "__main__":
if len(sys.argv) < 7:
print("用法:")
print(" 训练: python TCN_DPA_TA.py <Mobility> <Channel> <Mod> <Scheme> <SNR> train <Epochs> <BatchSize>")
print(" 测试: python TCN_DPA_TA.py <Mobility> <Channel> <Mod> <Scheme> <SNR> test")
sys.exit(1)
mobility = sys.argv[1]
channel_model = sys.argv[2]
modulation_order = sys.argv[3]
scheme = sys.argv[4]
snr_str = sys.argv[5]
mode = sys.argv[6]
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"Using device: {device}")
# ======================== 训练模式 ============================
if mode == 'train':
epochs = int(sys.argv[7])
batch_size = int(sys.argv[8])
train_file = f'./{mobility}_{channel_model}_{modulation_order}_{scheme}_TCN_training_dataset_{snr_str}.mat'
if not os.path.exists(train_file):
raise FileNotFoundError(f"训练数据文件不存在: {train_file}")
mat = loadmat(train_file)
Dataset = mat['TCN_Datasets'][0, 0]
X = Dataset['Train_X'] # (样本, 特征, 子载波)
Y = Dataset['Train_Y']
print(f"X shape: {X.shape}, Y shape: {Y.shape}")
num_samples, in_channels, in_subcarriers = X.shape
_, out_channels, out_subcarriers = Y.shape # out_subcarriers 应为 48
# ===== 论文配置：4层，kernel_size=2 =====
hidden_channels = [50, 50, 50, 50]
kernel_size = 2
dropout = 0.01
model = TCNWithAdaptive(in_channels, hidden_channels, out_channels,
out_subcarriers, kernel_size=kernel_size, dropout=dropout).to(device)
# 标准化（在线计算，避免内存爆炸）
train_x = torch.from_numpy(X).float()
train_y = torch.from_numpy(Y).float()
mean_x = train_x.mean(dim=(0, 2), keepdim=True) # (1, C, 1)
std_x = train_x.std(dim=(0, 2), keepdim=True)
mean_y = train_y.mean(dim=(0, 2), keepdim=True)
std_y = train_y.std(dim=(0, 2), keepdim=True)
eps = 1e-8
train_x = (train_x - mean_x) / (std_x + eps)
train_y = (train_y - mean_y) / (std_y + eps)
# 保存标准化参数（用于测试）
norm_params = {
'mean_x': mean_x.squeeze(0).cpu().numpy(),
'std_x': std_x.squeeze(0).cpu().numpy(),
'mean_y': mean_y.squeeze(0).cpu().numpy(),
'std_y': std_y.squeeze(0).cpu().numpy()
}
np.save(f'norm_params_{mobility}_{channel_model}_{modulation_order}_{scheme}.npy', norm_params)
print("标准化参数已保存 (形状: (C,1))。")
# 划分训练/验证 (75% 训练，25% 验证)
total = train_x.size(0)
train_n = int(0.75 * total)
train_dataset = data.TensorDataset(train_x[:train_n], train_y[:train_n])
val_x, val_y = train_x[train_n:].to(device), train_y[train_n:].to(device)
loader = data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=0)
criterion = nn.MSELoss()
# ===== 论文超参数：lr=0.003, StepLR step=17, gamma=0.8 =====
optimizer = optim.Adam(model.parameters(), lr=0.003)
scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=17, gamma=0.8)
best_loss = float('inf')
patience = 15
counter = 0
train_losses, val_losses = [], []
model_path = f'./{mobility}_{channel_model}_{modulation_order}_{scheme}_TCN_{snr_str}.pt'
print("开始训练...")
for epoch in range(epochs):
model.train()
total_loss = 0.0
for bx, by in loader:
bx, by = bx.to(device), by.to(device)
optimizer.zero_grad()
out = model(bx)
loss = criterion(out, by)
loss.backward()
optimizer.step()
total_loss += loss.item()
avg_train_loss = total_loss / len(loader)
train_losses.append(avg_train_loss)
model.eval()
with torch.no_grad():
val_out = model(val_x)
val_loss = criterion(val_out, val_y).item()
val_losses.append(val_loss)
scheduler.step()
current_lr = optimizer.param_groups[0]['lr']
print(f"Epoch {epoch+1}/{epochs} | Train Loss: {avg_train_loss:.6f} | Val Loss: {val_loss:.6f} | LR: {current_lr:.6f}")
if val_loss < best_loss:
best_loss = val_loss
counter = 0
torch.save(model.state_dict(), model_path)
print(" -> 最佳模型已保存。")
else:
counter += 1
if counter >= patience:
print(f"早停于 epoch {epoch+1}")
break
# 绘制损失曲线
plt.figure()
plt.plot(train_losses, label='Train Loss')
plt.plot(val_losses, label='Val Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend()
plt.savefig('loss_curve.png')
print("训练完成。损失曲线已保存。")
# ======================== 测试模式 ============================
else:
# 加载标准化参数
norm_file = f'norm_params_{mobility}_{channel_model}_{modulation_order}_{scheme}.npy'
if not os.path.exists(norm_file):
raise FileNotFoundError(f"标准化参数文件 {norm_file} 不存在，请先训练。")
norm_params = np.load(norm_file, allow_pickle=True).item()
mean_x = torch.from_numpy(norm_params['mean_x']).float() # (C,1)
std_x = torch.from_numpy(norm_params['std_x']).float()
mean_y = torch.from_numpy(norm_params['mean_y']).float()
std_y = torch.from_numpy(norm_params['std_y']).float()
# 确保形状为 (C,1)
def to_c1(t):
if t.dim() == 3:
t = t.squeeze(0)
if t.dim() == 1:
t = t.unsqueeze(1)
return t
mean_x = to_c1(mean_x); std_x = to_c1(std_x)
mean_y = to_c1(mean_y); std_y = to_c1(std_y)
eps = 1e-8
# 获取数据维度并构建模型（与训练一致）
test_files = [f for f in os.listdir('.') if f.startswith(f'{mobility}_{channel_model}_{modulation_order}_{scheme}_TCN_testing_dataset_') and f.endswith('.mat')]
if not test_files:
raise FileNotFoundError("未找到任何测试数据文件。")
sample_file = test_files[0]
mat = loadmat(sample_file)
Dataset = mat['TCN_Datasets'][0, 0]
X_sample = Dataset['Test_X']
Y_sample = Dataset['Test_Y']
in_channels = X_sample.shape[1]
out_channels = Y_sample.shape[1] # 应为 100
out_subcarriers = Y_sample.shape[2] # 应为 48
hidden_channels = [50, 50, 50, 50]
kernel_size = 2
dropout = 0.01
model = TCNWithAdaptive(in_channels, hidden_channels, out_channels,
out_subcarriers, kernel_size=kernel_size, dropout=dropout).to(device)
model_path = f'./{mobility}_{channel_model}_{modulation_order}_{scheme}_TCN_{snr_str}.pt'
if not os.path.exists(model_path):
alt_path = f'./{mobility}_{channel_model}_{modulation_order}_{scheme}_TCN_40.pt'
if os.path.exists(alt_path):
model_path = alt_path
print(f"使用备用模型: {alt_path}")
else:
raise FileNotFoundError(f"模型文件不存在: {model_path}")
model.load_state_dict(torch.load(model_path, map_location=device))
model.eval()
print("模型加载完成。")
# 定义数据子载波索引（Kset中剔除导频位置）
# 导频在 0-based 索引：6, 20, 31, 45
pilot_indices = [6, 20, 31, 45]
data_indices = [i for i in range(52) if i not in pilot_indices] # 48个
# 测试所有 SNR
snr_list = [0, 5, 10, 15, 20, 25, 30, 35, 40]
for snr in snr_list:
test_file = f'./{mobility}_{channel_model}_{modulation_order}_{scheme}_TCN_testing_dataset_{snr}.mat'
if not os.path.exists(test_file):
print(f"测试文件 {test_file} 不存在，跳过 SNR={snr}")
continue
print(f"\n===== 测试 SNR={snr} dB =====")
mat = loadmat(test_file)
Dataset = mat['TCN_Datasets'][0, 0]
X_test = Dataset['Test_X'] # (样本, 特征, 子载波)
yf_d_all = Dataset['Y_DataSubCarriers'] # (样本, 符号, 52) 复数接收信号
num_samples = X_test.shape[0]
num_sym = yf_d_all.shape[1] # 应为 50
# 提取数据子载波（48个）
yf_data = yf_d_all[:, :, data_indices] # (样本, 符号, 48)
# 存储最终估计（48个数据子载波）
h_est_data = np.zeros((num_samples, num_sym, 48), dtype=np.complex64)
with torch.no_grad():
for i in range(num_samples):
if i % 100 == 0:
print(f" 处理样本 {i}/{num_samples}")
# 1. TCN 初始估计
x_input = torch.from_numpy(X_test[i]).float() # (C, 52)
x_norm = (x_input - mean_x) / (std_x + eps)
x_tensor = x_norm.unsqueeze(0).to(device) # (1, C, 52)
out = model(x_tensor) # (1, out_channels, 48)
out_np = out.cpu().numpy().squeeze() # (out_channels, 48)
# 反标准化
out_inv = out_np * std_y.numpy() + mean_y.numpy() # (out_channels, 48)
# 构建初始估计（每个符号一个复数向量）
h_init = np.zeros((num_sym, 48), dtype=np.complex64)
for sym in range(num_sym):
real_part = out_inv[2*sym, :]
imag_part = out_inv[2*sym+1, :]
h_init[sym, :] = real_part + 1j * imag_part
# 2. DPA 迭代（从第二个符号开始）
h_dpa = h_init.copy()
for sym in range(1, num_sym):
y_eq = yf_data[i, sym, :] / h_dpa[sym-1, :]
# 使用修正后的硬判决（返回复数星座点）
q = demap_16qam(y_eq)
h_dpa[sym, :] = yf_data[i, sym, :] / q
# 3. 时域平均（TA），α=2
h_ta = h_dpa.copy()
alpha = 2.0
for sym in range(1, num_sym):
h_ta[sym, :] = (1 - 1/alpha) * h_ta[sym-1, :] + (1/alpha) * h_ta[sym, :]
# 存储
h_ta_only = h_init.copy()
for sym in range(1, num_sym):
h_ta_only[sym, :] = (1 - 1 / alpha) * h_ta_only[sym - 1, :] + (1 / alpha) * h_init[sym, :]
h_est_data[i, :, :] = h_ta_only
# 重构为完整的52个子载波（导频位置填0）
h_est_full = np.zeros((num_samples, num_sym, 52), dtype=np.complex64)
h_est_full[:, :, data_indices] = h_est_data
# 保存结果
save_file = f'./{mobility}_{channel_model}_{modulation_order}_{scheme}_TCN_Results_{snr}.mat'
scipy.io.savemat(save_file, {'hf_est': h_est_full})
print(f"结果已保存至 {save_file} (形状: {h_est_full.shape})")
print("所有测试完成。")
5 结论
本文从系统工程角度，实现了基于时间卷积网络与数据导频辅助的IEEE 802.11p车联网信道估计方案。设计了实虚交错的数据预处理策略，使复数域物理问题适用于实值神经网络；通过贝叶斯自动优化获得最佳超参数配置。实验在VTV-SDWW典型车信道下验证了该方案的有效性，误码率和信道估计精度均显著优于LS、DPA、STA、CDP、TRFI等经典方法，且优于LSTM等其他深度结构。
本工作不仅展示了TCN在物理层信号处理中的独特优势，也为深度学习与通信协议深度融合提供了可复现的范例。未来研究方向包括：
- 模型轻量化：通过剪枝、量化或知识蒸馏降低TCN推理延迟，满足车规级实时性要求。
- 多场景泛化：评估该方案在RTV、VTV-UC等其他车信道模型下的迁移表现，探索域自适应技术。
- 端到端联合设计：将信道估计与均衡、解调甚至解码视为整体，借助多任务学习寻求全局最优，进一步突破模块化设计的性能瓶颈。
仿真代码可见文末VX公众号，所见即所得
汇聚全球AI编程工具，助力开发者即刻编程。
更多推荐
7
0- 0
已为社区贡献8条内容
所有评论(0)