Сравнение точного LLR, макс. логарифмического приблизительного LLR и LLRNet для M-ary QAM

5G NR использует M-арную QAM модуляцию. В этом разделе рассматривается точность LLRNet при оценке значений LLR для 16-, 64- и 256-QAM модуляции. Предположим, что система M-ary QAM работает в условиях канала AWGN. Это предположение справедливо, даже когда канал является частотно избирательным, но символы выравниваются. Ниже приведены рассчитанные значения LLR для следующих трех алгоритмов:

16-QAM Оценка эффективности LLR

Вычислите точные и приблизительные значения LLR для значений символов, которые охватывают 99,7% ($$\pm \mathrm{}$$3λ) от возможных полученных символов. Если предположить, что AWGN, 99,7% $$(\mathrm{\pm }$$3λ) принятых сигналов будет находиться в $$диапазоне\underset{}{\mathrm{[}}\mathrm{maxs\in C}(Re\mathrm{(}s)\underset{3\lambda )}{\mathrm{+}}mins\in C\mathrm{}(Re(s\underset{3\lambda )}{\mathrm{)\; -}}]\mathrm{}\underset{Im}{\mathrm{+i[maxs\in C\; (}}(s)+\mathrm{3\lambda })$$mins∈C (Im (s) -3λ)]. Создание равномерно распределенных символов ввода/вывода в этом пространстве и использованиеqamdemod функция для вычисления точного LLR и аппроксимации значений LLR.

M = 16;             % Modulation order
k = log2(M);        % Bits per symbols
SNRValues = -5:5:5; % in dB
numSymbols = 1e4;
numSNRValues = length(SNRValues);
symOrder = llrnetQAMSymbolMapping(M);

const = qammod(0:15,M,symOrder,'UnitAveragePower',1);
maxConstReal = max(real(const));
maxConstImag = max(imag(const));

numBits = numSymbols*k;
exactLLR = zeros(numBits,numSNRValues);
approxLLR = zeros(numBits,numSNRValues);
rxSym = zeros(numSymbols,numSNRValues);
for snrIdx = 1:numSNRValues
    SNR = SNRValues(snrIdx);
    noiseVariance = 10^(-SNR/10);
    sigma = sqrt(noiseVariance);
    
    maxReal = maxConstReal + 3*sigma;
    minReal = -maxReal;
    maxImag = maxConstImag + 3*sigma;
    minImag = -maxImag;
    
    r = (rand(numSymbols,1)*(maxReal-minReal)+minReal) + ...
        1i*(rand(numSymbols,1)*(maxImag-minImag)+minImag);
    rxSym(:,snrIdx) = r;
    
    exactLLR(:,snrIdx) = qamdemod(r,M,symOrder,...
        'UnitAveragePower',1,'OutputType','llr','NoiseVariance',noiseVariance);
    approxLLR(:,snrIdx) = qamdemod(r,M,symOrder,...
        'UnitAveragePower',1,'OutputType','approxllr','NoiseVariance',noiseVariance);
end

Настройка и обучение нейронной сети

Настройка неглубокой нейронной сети с одним входным уровнем, одним скрытым уровнем и одним выходным уровнем. Введите принятый символ в сеть и обучите его оценке точных значений LLR. Поскольку сеть ожидает реальных входных данных, создайте вектор двух столбцов, где первый столбец является действительными значениями принятого символа, а второй столбец является мнимыми значениями принятого символа. Кроме того, выходной сигнал должен быть $\mathit{}\mathit{}$вектором k × N, $\mathit{где}$ k - количество битов на символ, $\mathit{а}$ N - количество символов.

nnInput = zeros(numSymbols,2,numSNRValues);
nnOutput = zeros(numSymbols,k,numSNRValues);
for snrIdx = 1:numSNRValues
    rxTemp = rxSym(:,snrIdx);
    rxTemp = [real(rxTemp) imag(rxTemp)];
    nnInput(:,:,snrIdx) = rxTemp;
    
    llrTemp = exactLLR(:,snrIdx);
    nnOutput(:,:,snrIdx) = reshape(llrTemp, k, numSymbols)';
end

Для 16-QAM символов скрытый слой имеет 8 нейронов, а выходной - 4 нейрона, что соответствует количеству битов на символ. Функция llrnetNeureNetwork возвращает предварительно сконфигурированную нейронную сеть. Обучите нейронную сеть трем различным значениям SNR. Использовать точные значения LLR, рассчитанные с помощью qamdemod в качестве ожидаемых выходных значений.

hiddenLayerSize = 8;
trainedNetworks = cell(1,numSNRValues);
for snrIdx=1:numSNRValues
    fprintf('Training neural network for SNR = %1.1fdB\n', ...
        SNRValues(snrIdx))
    x = nnInput(:,:,snrIdx)';
    y = nnOutput(:,:,snrIdx)';
    
    MSExactLLR = mean(y(:).^2);
    fprintf('\tMean Square LLR = %1.2f\n', MSExactLLR)
    
    % Train the Network. Use parallel pool, if available. Train three times
    % and pick the best one.
    mse = inf;
    for p=1:3
        netTemp = llrnetNeuralNetwork(hiddenLayerSize);
        if parallelComputingLicenseExists()
            [netTemp,tr] = train(netTemp,x,y,'useParallel','yes');
        else
            [netTemp,tr] = train(netTemp,x,y);
        end
        % Test the Network
        predictedLLRSNR = netTemp(x);
        mseTemp = perform(netTemp,y,predictedLLRSNR);
        fprintf('\t\tTrial %d: MSE = %1.2e\n', p, mseTemp)
        if mse > mseTemp
            mse = mseTemp;
            net = netTemp;
        end
    end
    
    % Store the trained network
    trainedNetworks{snrIdx} = net;
    fprintf('\tBest MSE = %1.2e\n', mse)
end

Training neural network for SNR = -5.0dB

	Mean Square LLR = 4.42

		Trial 1: MSE = 1.95e-06
		Trial 2: MSE = 1.22e-04
		Trial 3: MSE = 4.54e-06

	Best MSE = 1.95e-06

Training neural network for SNR = 0.0dB

	Mean Square LLR = 15.63

		Trial 1: MSE = 1.90e-03
		Trial 2: MSE = 5.03e-03
		Trial 3: MSE = 8.95e-05

	Best MSE = 8.95e-05

Training neural network for SNR = 5.0dB

	Mean Square LLR = 59.29

		Trial 1: MSE = 2.25e-02
		Trial 2: MSE = 2.23e-02
		Trial 3: MSE = 7.40e-02

	Best MSE = 2.23e-02

Показатель производительности для этой сети - среднеквадратическая ошибка (MSE). Конечные значения MSE показывают, что нейронная сеть сходится к значению MSE, которое по меньшей мере на 40 дБ меньше среднеквадратичных точных значений LLR. Следует отметить, что по мере увеличения SNR значения LLR также увеличиваются, что приводит к относительно более высоким значениям MSE.

Результаты для 16-QAM

Сравните оценки LLR LLRNet с оценками точного LLR и приблизительного LLR. Смоделировать символы 1e4 16-QAM и вычислить значения LLR с помощью всех трех методов. Не используйте символы, которые мы создали в предыдущем разделе, чтобы не давать LLRNet несправедливое преимущество, поскольку эти символы использовались для обучения LLRNet.

numBits = numSymbols*k;
d = randi([0 1], numBits, 1);

txSym = qammod(d,M,symOrder,'InputType','bit','UnitAveragePower',1);

exactLLR = zeros(numBits,numSNRValues);
approxLLR = zeros(numBits,numSNRValues);
predictedLLR = zeros(numBits,numSNRValues);
rxSym = zeros(length(txSym),numSNRValues);
for snrIdx = 1:numSNRValues
    SNR = SNRValues(snrIdx);
    sigmas = 10^(-SNR/10);
    r = awgn(txSym,SNR);
    rxSym(:,snrIdx) = r;
    
    exactLLR(:,snrIdx) = qamdemod(r,M,symOrder,...
        'UnitAveragePower',1,'OutputType','llr','NoiseVariance',sigmas);
    approxLLR(:,snrIdx) = qamdemod(r,M,symOrder,...
        'UnitAveragePower',1,'OutputType','approxllr','NoiseVariance',sigmas);
    
    net = trainedNetworks{snrIdx};
    x = [real(r) imag(r)]';
    tempLLR = net(x);
    predictedLLR(:,snrIdx) = reshape(tempLLR, numBits, 1);
end

qam16Results.exactLLR = exactLLR;
qam16Results.approxLLR = approxLLR;
qam16Results.predictedLLR = predictedLLR;
qam16Results.RxSymbols = rxSym;
qam16Results.M = M;
qam16Results.SNRValues = SNRValues;
qam16Results.HiddenLayerSize = hiddenLayerSize;
qam16Results.NumSymbols = numSymbols;

На следующем рисунке показана точная LLR, макс. log приблизительная LLR и оценка LLRNet значений LLR в сравнении с действительной частью принятого символа для нечетных битов. LLRNet соответствует точным значениям LLR даже для низких значений SNR.

llrnetPlotLLR(qam16Results,'16-QAM LLR Comparison')

64-QAM и 256-QAM Оценка LLR

Проверьте, может ли LLRNet оценить значения LLR для QAM более высокого порядка. Повторите тот же процесс, что и для 16-QAM 64-QAM и 256-QAM с помощью функции llrnetQAMLLR helper. На следующих рисунках показана точная LLR, макс. log приблизительная LLR и оценка LLRNet значений LLR в сравнении с действительной частью принятого символа для нечетных битов.

trainNow = false;
if trainNow
    % Parameters for 64-QAM
    simParams(1).M = 64; %#ok<UNRCH>
    simParams(1).SNRValues = 0:5:10;
    simParams(1).HiddenLayerSize = 16;
    simParams(1).NumSymbols = 1e4;
    simParams(1).UseReLU = false;
    
    % Parameters for 256-QAM
    simParams(2).M = 256;
    simParams(2).SNRValues = 0:10:20;
    simParams(2).HiddenLayerSize = 32;
    simParams(2).NumSymbols = 1e4;
    simParams(2).UseReLU = false;
    
    simResults = llrnetQAMLLR(simParams);
    llrnetPlotLLR(simResults(1),sprintf('%d-QAM LLR Comparison',simResults(1).M))
    llrnetPlotLLR(simResults(2),sprintf('%d-QAM LLR Comparison',simResults(2).M))
else
    load('llrnetQAMPerformanceComparison.mat', 'simResults')
    for p=1:length(simResults)
        llrnetPlotLLR(simResults(p),sprintf('%d-QAM LLR Comparison',simResults(p).M))
    end
end

DVB-S.2 Частота ошибок пакетов

DVB-S.2 система использует мягкий демодулятор для формирования входных сигналов для декодера LDPC. Моделирование частоты ошибок пакетов (PER) DVB-S.2 системы с 16-APSK модуляцией и кодом 2/3 LDPC с использованием точного LLR, приблизительного LLR и LLRNet с использованием функции llrNetDVBS2PER. Эта функция использует comm.PSKDemodulator Системный объект и dvbsapskdemod для вычисления точных и приблизительных значений LLR и comm.AWGNChannel Системный объект для моделирования канала.

Набор simulateNow true (или выберите «Simulate» в раскрывающемся списке), чтобы выполнить моделирование PER для значений subsystemType, EsNoValues, и numSymbols с помощью функции llrnetDVBS2PER. Если установлен Toolbox™ параллельных вычислений, эта функция использует parfor для параллельного выполнения моделирования. На процессоре Intel ® Xeon ® W-2133 CPU @ 3.6GHz и при использовании кода запуска параллельных пулов (Parallel Computing Toolbox) размера 6 моделирование занимает около 40 минут. НаборsimulateNow кому false (или выберите «Plot saved results» в раскрывающемся списке), чтобы загрузить результаты PER для значений subsystemType='16APSK 2/3', EsNoValues=8.6:0.1:8.9, и numSymbols=10000.

Набор trainNow кому true (или выберите «Train LLRNet» в раскрывающемся списке) для обучения нейронных сетей LLR для каждого значения EsNoValues, для данного subsystemType и numSymbols. Если установлен Toolbox™ параллельных вычислений, train функция может вызываться с опциональной парой имя-значение 'useParallel' установить в значение 'yes' для параллельного выполнения моделирования. На процессоре Intel ® Xeon ® W-2133 CPU @ 3.6GHz и при использовании кода запуска параллельных пулов (Parallel Computing Toolbox) размера 6 моделирование занимает около 21 минуты. НаборtrainNow на false (или выберите «Use saved networks» в раскрывающемся списке) для загрузки нейронных сетей LLR, обученных для subsystemType='16APSK 2/3', EsNoValues=8.6:0.1:8.9.

Дополнительные сведения о моделировании DVB-S.2 PER см. в примере DVB-S.2 Link, Including LDPC Coding in Simulink. Для получения дополнительной информации по обучению сети см. функции llrnetTrainDVBS2LLRNetwork и [1].

simulateNow = false;
if simulateNow
    subsystemType = '16APSK 2/3'; %#ok<UNRCH>
    EsNoValues = 8.6:0.1:8.9;     % in dB
    numFrames = 10000;
    numErrors = 200;
    
    trainNow = false;
    if trainNow && (~strcmp(subsystemType,'16APSK 2/3') || ~isequal(EsNoValues,8.6:0.1:9))
        % Train the networks for each EsNo value
        numTrainSymbols = 1e4;
        hiddenLayerSize = 64;
        llrNets = llrnetTrainDVBS2LLRNetwork(subsystemType, EsNoValues, numTrainSymbols, hiddenLayerSize);
    else
        load('llrnetDVBS2Networks','llrNets','subsystemType','EsNoValues');
    end
    
    % Simulate PER with exact LLR, approximate LLR, and LLRNet
    [perLLR,perApproxLLR,perLLRNet] = llrnetDVBS2PER(subsystemType,EsNoValues,llrNets,numFrames,numErrors);
    llrnetPlotLLRvsEsNo(perLLR,perApproxLLR,perLLRNet,EsNoValues,subsystemType)
else
    load('llrnetDVBS2PERResults.mat','perApproxLLR','perLLR','perLLRNet',...
        'subsystemType','EsNoValues');
    llrnetPlotLLRvsEsNo(perLLR,perApproxLLR,perLLRNet,EsNoValues,subsystemType)
end

Результаты показывают, что LLRNet почти соответствует производительности точного LLR без использования каких-либо дорогостоящих операций, таких как логарифм и экспоненциальный.

Дальнейшие исследования

Попробуйте использовать различные схемы модуляции и кодирования для системы DVB-S.2. Полный список типов модуляции и скоростей кодирования приведен в примере DVB-S.2 Link, включая LDPC-кодирование в Simulink. Можно также попробовать использовать разные размеры скрытого уровня сети, чтобы уменьшить количество операций и измерить потери производительности по сравнению с точным LLR.

В примере используются эти вспомогательные функции. Изучите эти файлы для получения подробной информации о реализации.

Ссылки

[1] О. Шенталь и Дж. Хойдис «,» Machine LLRning «: Обучение мягкой демодуляции», 2019 IEEE Globecom Workshops (GC Wkshps), Вайколоа, HI, USA, 2019, стр. 1-7.