LDPC信道编解码MATLAB实现:从校验矩阵到5G QC-LDPC避坑指南

本文还有配套的精品资源,点击获取 menu-r.4af5f7ec.gif

本文系统讲解LDPC信道编解码的MATLAB实现,涵盖稀疏校验矩阵H构建、生成矩阵G推导(GF(2)高斯消元)、BP/最小和迭代译码原理,以及5G NR QC-LDPC基图扩展、编码路径选择与译码优化。重点剖析H/G匹配、LLR符号方向、归一化因子、早停机制、稀疏存储等5类工程常见错误,并提供无噪声验证、校验子断言等高效调试方法,支撑通信物理层仿真与算法落地。

简介:LDPC码以稀疏校验矩阵实现接近香农限的纠错性能,支持并行迭代解码,在移动通信、卫星通信与数据存储系统中广泛应用。面向通信工程学习者与算法研究人员,这份LDPC.m源码完整展示了LDPC编解码链路:从校验矩阵H的构建(支持随机生成或标准码库选取)、生成矩阵G的推导(满足GH^T=0),到AWGN信道加噪,再到基于Tanner图的置信传播(BP)消息传递迭代解码,包含初始化、迭代停止判决与软/硬输出,并给出误码率或误块率评估入口。压缩包共1个文件,为单个MATLAB脚本,大小仅4KB,函数结构清晰,适合直接运行或嵌入自己的仿真框架,可用于课程实验、毕业设计或科研预研。已有155人学习,可作为理解LDPC码字结构、分析不同构造方式、调试解码收敛行为,乃至延伸学习Polar码与Turbo码的实用起点。通过修改校验矩阵的稀疏度与迭代次数,读者能直观比较不同信噪比下的译码表现,加深对低密度校验设计和迭代译码机制的理解,也为工程参数优化提供参考。

1. LDPC 信道编解码到底解决什么问题,拿到 rar 包先别急着解压

LDPC(低密度奇偶校验码)是 5G NR、DVB-S2、Wi-Fi 都在用的信道编码方案,也是做物理层仿真绕不开的一块硬骨头。这个标题里的 rar 包,从命名就能看出是给你一套 LDPC 信道编解码的 MATLAB 实现——打开之前搞清楚它到底在做什么,比急着跑误码率曲线更重要。它要解决的是:在 AWGN 或衰落信道里,如何把信息比特变成带冗余的码字发送出去,再通过迭代译码把被噪声污染的信号恢复成原始比特。适合两类人:一是课程或科研需要复现编解码链路的学生,二是做基带算法验证、想快速拿到一个可用参考实现的工程师。后者尤其要明白,能跑的代码和能用的代码之间,差着一整套参数适配和验证流程。

2. 先看穿 LDPC 编解码的三个输入:H 矩阵、G 矩阵和迭代译码

2.1 稀疏校验矩阵 H 是 LDPC 的“灵魂”,它决定了码率和编码复杂度

LDPC 的一切从校验矩阵 H 开始。H 是一个 M×N 的二元矩阵,N 是码字长度,M 是校验位数量,信息位长度 K = N - M,码率 R = K / N。拿最常见的 (3,6) 规则码举例,每行有 6 个 1,每列有 3 个 1,1 的密度远低于普通随机矩阵,这才配得上“低密度”三个字。

每一行对应一个校验方程:一个合法码字 c 必须满足 c·H^T = 0(在 GF(2) 域上)。这个约束看起来简单,却是编码和译码共同的基础。编码要保证输出码字落在这组方程的解空间里,译码则是利用这些方程去纠正信道引入的错误比特。

稀疏性直接决定了工程可行性。H 可以画成 Tanner 图:左边变量节点对应每一列(每个比特),右边校验节点对应每一行(每个方程),H 里的 1 就是两者之间的连线。译码时消息只沿着这些连线传递,稀疏意味着连线少、计算量可控。如果 H 是稠密矩阵,每次迭代的更新量会爆炸,所谓“逼近香农极限”也就失去了工程意义。

我在拿到一个 LDPC 仿真包时,第一件事永远是先看 H 怎么构造的:是随机生成的正则码,还是准循环码,这决定了后面能不能直接用到 5G NR 这类真实场景。

2.2 从 H 推出 G:GF(2) 高斯消元与系统形式的坑

编码需要另一个矩阵 G。信息位向量 u(长度 K)通过 G(K×N)变成码字 c = u·G,并且必须满足 c·H^T = 0。最常见的构造是系统形式:G = [I | P],其中 I 是 K×K 单位阵,P 是 K×M 的奇偶部分。对应的校验矩阵写成 H = [P^T | I]。

为什么工程上都喜欢系统形式?因为编码后码字的前 K 位就是原始信息位,后面 M 位是校验位。调试时直接看前几位就知道编码对不对,省去解码映射的麻烦。

如果 rar 包里只给了 H 而要自己求 G,标准做法是 GF(2) 高斯消元。下面是一个示意实现,注意它假设 H 已经满秩且能化成系统形式:

function G = h2g_system(H)
    [M, N] = size(H);
    K = N - M;
    A = H(:, 1:K);       % 前 K 列
    B = H(:, K+1:N);     % 后 M 列
    
    % 这里需要自己实现 GF(2) 上的高斯消元,目标是把 A 化为单位阵
    % 求出 A 在 GF(2) 上的逆 A_inv
    % 完整实现要处理 A 不满秩的情况:先做列置换,记录置换映射
    
    P = mod(A_inv * B, 2);   % P 是 K×M
    G = [eye(K), P];         % 系统形式生成矩阵
end

代码里最关键的是“假设 A 可逆”这句注释。真实场景中 H 的前 K 列不一定满秩,必须对 H 做列置换才能得到系统形式。置换后的列顺序会影响 c = u·G 里信息位的位置,如果没有把置换映射保存下来、编码后再映射回去,译码端拿到的软信息顺序会整体错乱。这是后续避坑章里最容易翻车的地方。

2.3 BP 译码与最小和译码:迭代收敛和性能的取舍

译码是 LDPC 真正精彩的部分。置信传播(BP)译码在 Tanner 图上交换消息:变量节点告诉校验节点“这个比特的似然是多少”,校验节点根据校验方程约束更新这个估计,再传回变量节点。如此往复迭代,直到硬判决后的码字满足所有校验方程或者达到最大迭代次数。

标准 BP 在校验节点更新时要计算 tanh 乘积,数学上漂亮但硬件开销大。最小和译码做了一个巧妙的近似:用“符号乘积 + 最小绝对值”替代 tanh 乘积。代价是性能损失 0.1 到 0.3 dB,换来的是计算量降一个量级,并且完全避开浮点 tanh。工程上几乎都用最小和或其变体。

校验节点更新的最小和近似核心逻辑如下:

% Lv 是变量节点发给当前校验节点的消息
% 对每个校验节点 i,遍历它连接的变量节点 j
for j = idx
    others = setdiff(idx, j);          % 除 j 外同在一个校验方程里的节点
    S = prod(sign(Lv(others)));       % 符号一致性
    m = min(abs(Lv(others)));         % 幅度取最小
    E(i, j) = S * m;                  % 传回给变量节点 j 的校验消息
end

如果做归一化最小和,把 E(i, j) 乘以一个小于 1 的因子 alpha,典型值在 0.7 到 0.8 之间。alpha 太小收敛慢,太大容易震荡,后面参数章节会展开讲。

2.4 一个能跑的最小 LDPC 编解码链路:从 H 矩阵到误码率

前面理论讲再多,不如一个能跑的最小例子直观。下面这个脚本不依赖任何通信工具箱,用 12 比特码长、1/2 码率的 (3,6) 规则码走完编码、调制、加噪、最小和译码全流程。

% 最小 LDPC 编解码仿真:N=12, K=6, 1/2 码率,无工具箱依赖
K = 6; M = 6; N = K + M;

% 系统形式构造:G = [I | P],H = [P' | I]
P = [1 1 0 1 0 0;
     1 0 1 0 1 0;
     0 1 1 0 0 1;
     1 0 0 1 1 0;
     0 1 0 1 0 1;
     0 0 1 0 1 1];
G = [eye(K), P];
H = [mod(P', 2), eye(M)];

% 编码并立刻验证校验方程
u = randi([0 1], 1, K);
c = mod(u * G, 2);
assert(all(mod(c * H', 2) == 0), '编码结果不满足校验方程');

% BPSK 调制 + AWGN 信道
EbN0_dB = 4;
R = K / N;
EsN0_dB = EbN0_dB + 10*log10(R);
noiseVar = 1 / (2 * 10^(EsN0_dB/10));
x = 1 - 2*c;                          % 0 -> +1, 1 -> -1
y = x + sqrt(noiseVar) * randn(1, N);

% 信道 LLR:对 BPSK + AWGN,LLR = 2*y / noiseVar
Lch = 2 * y / noiseVar;

% 最小和译码(flooding 调度)
maxIter = 20;
V2C = repmat(Lch, M, 1);        % V2C(i,j): 变量节点 j 发给校验节点 i 的消息
c_hat = zeros(1, N);

for iter = 1:maxIter
    % 校验节点更新
    C2V = zeros(M, N);
    for i = 1:M
        idx = find(H(i, :));
        for j = idx
            others = setdiff(idx, j);
            C2V(i, j) = prod(sign(V2C(i, others))) * min(abs(V2C(i, others)));
        end
    end
    
    % 变量节点更新
    for j = 1:N
        idx = find(H(:, j));
        for i = idx
            others = setdiff(idx, i);
            V2C(i, j) = Lch(j) + sum(C2V(others, j));
        end
    end
    
    % 后验 LLR 硬判决,校验子全零则提前停止
    LLR_post = Lch + sum(C2V, 1);
    c_hat = double(LLR_post < 0);
    if all(mod(c_hat * H', 2) == 0)
        break;
    end
end

ber = sum(c_hat ~= c) / N;
fprintf('Eb/N0 = %g dB, BER = %g, 迭代次数 = %d\n', EbN0_dB, ber, iter);

几个参数要重点说明。噪声方差 noiseVar 的换算关系是 BPSK 下符号能量 Es = 1,所以 N0/2 = 1 / (2·EsN0),而 EsN0 = EbN0 · R,dB 域就是加 10log10(R)。信道 LLR 的正负号必须和 BPSK 映射一致:0 映射到 +1,1 映射到 -1,LLR 为正是发 0 的置信度。硬判决里 LLR_post < 0 判为 1,方向弄反的话译码性能会比不译码还差。早停条件用的是校验子全零,这个判断在浮点译码里是免费的,能省掉大量无效迭代。

3. 复现 5G NR 的 QC-LDPC 编解码:基图 BG1、循环移位与可落地的流程

3.1 为什么工程实现都选 QC-LDPC,而不是随机稀疏矩阵

上一章的 12 比特例子能跑,但放到 5G NR 场景就不够用了。5G 的 LDPC 码长可以到几千比特,如果 H 是随机生成的稀疏矩阵,光存储就要存几千乘几千的二元矩阵,编码时还要做 GF(2) 高斯消元,复杂度完全不可接受。

工程实现基本都用准循环 LDPC,也就是 QC-LDPC。它的核心思想是把 H 矩阵分成若干 Z×Z 的子块,每个子块要么是全零块,要么是单位阵的循环移位。这样一个大 H 只需要用基图矩阵 BG 和扩展因子 Z 描述,存储量从几百万比特压缩到几十个整数。

5G NR 定义了两种基图:BG1 是 68 行 × 22 列,适合中高速率和较大传输块;BG2 是 42 行 × 52 列,适合低码率和短传输块。协议表里每个元素是 -1 或者 0 到 Z-1 的整数:-1 表示全零块,非负整数 s 表示 Z×Z 单位阵循环右移 s 位。扩展因子 Z 根据传输块大小和信息位长度从协议规定的集合里选。这段话就是 5G 物理层里“ldpc 编码”最常见的打开方式。

3.2 从协议基图到校验矩阵 H 的扩展代码

拿到 BG 基图和 Z,扩展出完整 H 的代码不复杂,关键是把两层循环写对:

function H = expandQC(bg, Z)
    [Br, Bc] = size(bg);
    H = zeros(Br * Z, Bc * Z);
    for r = 1:Br
        for c = 1:Bc
            s = bg(r, c);
            if s >= 0
                block = circshift(eye(Z), s, 2);   % 单位阵循环右移 s 列
                H((r-1)*Z+1 : r*Z, (c-1)*Z+1 : c*Z) = block;
            end
        end
    end
end

参数说明:bg 里每个元素必须在 -1 到 Z-1 之间,这是协议的隐含约束。circshift 的第三个参数 2 表示沿列方向移位,也就是循环右移。如果表里给的是左移定义,这里要换成 shift 取反,这是看协议实现最容易出偏差的细节。

这个实现是教学向的,够清楚但不高效。H 展开成稠密矩阵后,BG1 全展开是 68Z 行 × 22Z 列,Z 取 256 时接近 17408 × 5632,MATLAB 里直接建零矩阵还能忍受,但每帧都重建就非常愚蠢。后面避坑章会专门讲性能问题。

3.3 编码侧:两条可落地的路径

QC-LDPC 的编码有两条路。

第一条是 MATLAB 通信工具箱路线。较新的版本提供了直接的 5G NR LDPC 接口,用法是:

% 使用通信工具箱的 5G NR LDPC 编码器
cfgEnc = ldpcEncoderConfig(bg);          % bg 是 68x22 或 42x52 的基图矩阵
codeword = ldpcEncode(u, cfgEnc);        % u 是信息比特列向量

这套接口自动处理速率匹配之前的基础编码,适合先验证链路性能。注意 bg 矩阵里的 -1 和循环移位值需要严格按 38.212 的表填,不能拿随机矩阵凑数。

第二条是自己做 G 矩阵乘法。如果你手里的代码包没有工具箱依赖,只能沿用上一章的 c = mod(u·G, 2) 思路。问题在于 QC-LDPC 的 G 矩阵不再稀疏,K×N 的二进制矩阵乘法的计算量和存储都很夸张。实际工程会用 H 的特殊结构直接编码,利用基图里的双对角结构做递推校验位生成,那套做法不是几百字能讲完的。我的建议是:先用 MATLAB 工具箱跑通参考曲线,再去理解内部结构,不要一步跳到手工实现。

3.4 译码侧:最小和译码与早停判断的最小实现

译码侧相对独立,把 2.4 的算法封装成函数,适配大规模 H:

function [c_hat, iter] = ldpc_min_sum(Lch, H, maxIter)
    [M, N] = size(H);
    V2C = repmat(Lch, M, 1);
    for iter = 1:maxIter
        C2V = zeros(M, N);
        for i = 1:M
            idx = find(H(i, :));
            for j = idx
                others = setdiff(idx, j);
                C2V(i, j) = prod(sign(V2C(i, others))) * min(abs(V2C(i, others)));
            end
        end
        for j = 1:N
            idx = find(H(:, j));
            for i = idx
                others = setdiff(idx, i);
                V2C(i, j) = Lch(j) + sum(C2V(others, j));
            end
        end
        LLR_post = Lch + sum(C2V, 1);
        c_hat = double(LLR_post < 0);
        if all(mod(c_hat * H', 2) == 0)
            break;
        end
    end
end

这段代码逻辑和最小例子一致,只是把 H 作为参数传进来。对 QC-LDPC 大矩阵,双重 find 循环效率不够,但作为参考实现是够用的。工程优化方向有两个:一是把 H 转成稀疏矩阵后用逻辑索引批量更新;二是按基图索引更新消息,只在相连块之间计算,复杂度从 O(N·dv) 降到 O(Z·块数)。早停判断的价值在大迭代次数下尤其明显,实测平均迭代次数能降 40% 左右。

4. 参数怎么设、误码率曲线怎么读:一次完整仿真的落地配置

4.1 仿真链路的最小参数表:码长、码率、迭代次数、信噪比范围

跑 LDPC 仿真最先要定一组能出结果的参数。我常用的起点如下:

参数 推荐值 影响
码长 N 648 / 1296 / 1944 越长性能越好,仿真越慢
码率 R 1/2 或 2/3 码率越高,瀑布区越靠右
扩展因子 Z 按 N/22 和基图选 决定 H 大小和编码效率
最大迭代次数 20(浮点)/ 8(定点) 太小有错误平底,太大耗时
归一化因子 alpha 0.75(最小和) 补偿最小和近似损失
Eb/N0 范围 1 到 8 dB,步进 0.5 dB 低于瀑布区全是误码,高于则无限接近 0
每信噪比帧数 至少 100 帧,误码率目标 1e-3 时要几千帧 帧数不够曲线抖动剧烈

最大迭代次数是最容易设错的地方。浮点 BP 迭代 50 次还有明显增益,但最小和迭代 8 次和 20 次的差距很小;如果硬件定点实现,迭代 8 次是性价比不错的折中。归一化因子 alpha 不是越大越好,0.75 是我做大多数码率的起步值,性能敏感的码可以扫一遍 0.6 到 0.9。

4.2 误码率曲线的三条参照:未编码 BPSK、理论界限、实测曲线

拿到测量曲线后,先别急着贴进报告。我会同时画三条线:未编码 BPSK 的误码率曲线、LDPC 实测曲线、以及同等码率下的香农极限或理论界限。未编码 BPSK 是下限参照,LDPC 曲线必须在它左边,否则要么实现有 bug,要么信噪比换算错了。5G NR 的 LDPC 在 1/2 码率下,距离香农极限通常在 1 dB 以内,看到大于 2 dB 的差距就要怀疑链路实现。

曲线形状也值得注意。LDPC 误码率曲线不是均匀下降的,而是有一段斜率陡峭的“瀑布区”,进入瀑布区后误码率随 Eb/N0 增加快速下降。如果曲线下降很平缓,没有明显的瀑布区陡降,通常说明译码实现有问题,比如消息更新方向错了或者 LLR 正负号反了。高信噪比端如果出现“错误平底”,也就是误码率不再下降,多半是迭代次数不够或者最小和归一化没调好,而不是信道本身的问题。

4.3 常见误用一:把 H 和 G 当成黑匣子直接调,没先确认满秩和匹配

很多 rar 包里同时给了 H 和 G,看起来可以直接用。但 H 和 G 不一定匹配:H 可能经过列置换,G 可能对应另一种列顺序。接手代码后第一次编码前,一定要先写一句校验:对随机信息位编码后检查 c·H^T 是否全零。这条断言的价值远超它看起来的简单程度,能挡掉一大半“误码率为什么差 3 个 dB”的深夜崩溃。

4.4 常见误用二:仿真循环里重复生成 H 矩阵,慢到怀疑人生

MATLAB 仿真的经典翻车就是把 H 扩展写进 SNR 或帧循环里。BG1 在 Z=256 时展开一次就要几十毫秒,看起来不慢,但乘上几百帧再乘上几十个信噪比点,就是几十分钟的纯浪费。正确做法是把 H 扩展、G 生成这类一次性计算放在所有循环外面:

% 错误:每帧都重建 H
for snr = 1:8
    for frame = 1:1000
        H = expandQC(bg, Z);   % 重复劳动,且每次都把 H 撑成大型稀疏矩阵
        % 编解码...
    end
end

% 正确:循环外只做一次
H = expandQC(bg, Z);
for snr = 1:8
    for frame = 1:1000
        % 编解码,H 只读不写
    end
end

这个改动对仿真速度的提升是数量级的。顺带提醒,译码器里的 V2C、C2V 消息矩阵每次迭代要清零,但矩阵本身在迭代循环外预先分配,不要在迭代内部调用 zeros 重新分配。

5. 避坑:从 H 矩阵到浮点定点,5 个最容易翻车的点

5.1 编码输出不满足校验方程:G 和 H 的列顺序对不上

现象:编码后跑校验子断言直接报错,或者误码率在 0.5 附近徘徊。 原因:H 在生成时做过列置换,但 G 没有对应调整。系统形式要求 G = [I | P]、H = [P^T | I],只要 H 不是天然这种形式,直接套公式就会错位。 解决:编码后第一件事就是断言 c·H^T = 0。如果失败,对 H 做列置换的同时记录置换向量 perm,编码后再把 c 的列按 perm 的逆序映射回去。这个映射关系建议写成独立函数,别散落在仿真脚本里。

5.2 高信噪比下误码率出现平底:迭代次数和归一化因子没配对

现象:Eb/N0 到 7 dB 以后误码率不再下降,曲线拖出一条平底。 原因:最小和译码本身有近似损失,迭代次数不足时错误分量无法收敛;归一化因子取得太大或太小也会让迭代在震荡中结束。 解决:先把归一化因子固定 0.75,把最大迭代从 20 提到 50,看平底是否消失。如果消失,说明是迭代预算问题;如果平底仍明显,再多扫几个 alpha 值,0.6、0.7、0.8 各跑一遍对比。定点实现里还要注意 LLR 量化位数,低于 6 bit 时平底几乎是必然的。

5.3 译码性能比硬判决还差:LLR 符号方向搞反了

现象:译码后的误码率高于不译码的硬判决结果。 原因:这是最讽刺的一类 bug。BPSK 映射如果用 0 到 +1、1 到 -1,LLR 正数应表示倾向 0,硬判决应判 LLR > 0 为 0。任何一个环节把符号取反,译码器就会去“纠正”原本正确的比特。 解决:构造一个无噪声输入,把信道 LLR 设为很大的正数或负数,看译码输出是否和发送码字完全一致。这个测试 5 秒能查出问题,我拿到任何新译码器都先跑这一条。具体做法下一节展开。

5.4 仿真速度慢到无法忍受:随机 H 上的双重循环更新消息

现象:每帧译码要几秒,几万帧根本跑不完。 原因:对随机的稀疏 H 用 find(H(i,:)) 加 setdiff 逐节点更新,复杂度虽然线性,但 MATLAB 的循环开销极大;更糟的是 H 用了稠密矩阵存储,内存和缓存都扛不住。 解决:H 直接存成 sparse 类型;译码前把每个变量节点的邻居列表、每个校验节点的邻居列表预先算好存成 cell 数组,迭代时只遍历邻居列表。这一步做完,仿真速度通常能快 5 到 10 倍。QC-LDPC 还可以按基图块索引更新,把 Z 个节点的消息一次向量化运算,但那属于工程优化,先把普通稀疏索引版本跑通。

5.5 QC-LDPC 内存爆掉:H 扩展成全矩阵再塞进译码器

现象:Z 取 256 以上时 MATLAB 直接卡死或报告内存不足。 原因: expandQC 返回的全矩阵很大,BG1 全展开约 17408 × 5632 的 double 矩阵,几个副本加起来轻松占掉数 GB。同事之间最爱互相甩锅的“内存玄学”,十有八九是这个原因。 解决:H 转成 sparse 再返回,或干脆不展开,译码时只保存基图和 Z,所有消息矩阵按块组织。sparse 存储下 17408 × 5632 的 H 只有约 20 万个非零元素,内存占用从 GB 级降到几十 MB。做误码率曲线时优先用稀疏路径,全展开只用来做小规模验证。

6. 验证 LDPC 编解码正确性的 3 个便宜办法

6.1 无噪声译码必须完全恢复原码字

这是性价比最高的验证。把信道噪声方差设成 0,或直接把 LLR 设成 ±一个大数,跑一次译码,输出必须和发送码字逐位一致。不一致说明消息更新方向、符号或邻居索引里有 bug,先查这个再谈性能。

6.2 校验子断言作为每次仿真的基础设施

编码后、译码后各跑一次 mod(c*H',2) 全零判断,写进脚本里而不是注释掉。它是后面所有参数实验的地基,比任何打印 log 都好用。

6.3 瀑布区斜率和归一化因子扫描

性能验证不只看单个点。取 4 到 5 个信噪比点,看误码率曲线是否出现明显瀑布区拐点;再对比 alpha 为 1.0、0.75、0.6 的三条曲线,确认最小和近似损失可控。我个人的习惯是:任何新拿到的 LDPC 代码包,先跑无噪声校验子测试,再跑 1e-3 误码率附近的一个点,最后才铺开整条曲线。这个顺序救过我很多次,希望帮到你。

本文还有配套的精品资源,点击获取 menu-r.4af5f7ec.gif

评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值
⌂ 换网址