Обучение и проверка нейронной сети для оценки LLR

Этот пример использует:

Этот пример показов, как сгенерировать сигналы и нарушения канала для обучения нейронной сети, называемой LLRNet, для оценки точных журналов коэффициентов вероятности (LLR).

Большинство современных систем связи, таких как 5G New Radio (NR) и Digital Video Broadcasting for Satellite, Second Generation (DVB-S.2), используют алгоритмы прямой коррекции ошибок, которые выигрывают от мягких демодулированных битовых значений. Эти системы вычисляют значения мягких бит с помощью подхода LLR. LLR определяется как журнал отношения вероятности бита, равного 0 к вероятности бита, равного 1 или

$l_{i} ≜ \log (\frac{P_{r} (c_{i} = 0 | s_{}^{ˆ})}{P_{r} (c_{i} = 1 | s_{}^{ˆ})})$ , $i = 1, . . ., k$

где $s_{}^{ˆ}$ является k-битным принятым символом, и $c_{i}$ является $i^{t h}$ бит символа. Принимая аддитивный канал белого Гауссова шума (AWGN), точный расчет выражения LLR является

$l_{i} ≜ \log (\frac{\sum_{s \in c_{i}^{0}} \exp (- \frac{‖ s_{}^{ˆ} - s ‖_{2}^{2}}{σ^{2}})}{\sum_{s \in c_{i}^{1}} \exp (- \frac{‖ s_{}^{ˆ} - s ‖_{2}^{2}}{σ^{2}})})$

где $σ^{2}$ - отклонение шума. Экспоненциальные и логарифмические вычисления являются очень дорогостоящими, особенно во встраиваемых системах. Поэтому в большинстве практичных систем используются приближения max-log. Для заданного массива $x$ , максимальное логарифмическое приближение

$\log (\sum_{j} \exp (- x_{j}^{2})) \approx \max_{j} (- x_{j}^{2})$ .

Подстановка этого в точном выражении LLR приводит к максимальному логарифмическому приближению LLR [1]

$l_{i} \approx \frac{1}{σ^{2}} (\min_{s \in C_{i}^{1}} ‖ s_{}^{ˆ} - s ‖_{2}^{2} - \min_{s \in C_{i}^{0}} ‖ s_{}^{ˆ} - s ‖_{2}^{2})$ .

LLRNet использует нейронную сеть, чтобы оценить точные значения LLR, учитывая принятый символ комплекса основной полосы для заданного значения ОСШ. Мелкая сеть с небольшим количеством скрытых слоев имеет потенциал для оценки точных значений LLR в сложности, подобной приблизительному алгоритму LLR [1].

Сравнение точных LLR, приблизительных LLR Max-Log и LLRNet для M-арного QAM

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

Точный LLR
Максимальная аппроксимация LLR
LLRNet

16-QAM оценки LLR Эффективности

Вычислите точные и приблизительные значения LLR для значений символов, которые покрывают 99,7% ( $\pm 3 σ$ ) возможных полученных символов. Принимая AWGN, 99,7% ( $\pm 3 σ$ ) из принятых сигналов будет находиться в области значений $[\max_{s \in C} (R e (s) + 3 σ) \min_{s \in C} (R e (s) - 3 σ)] + i [\max_{s \in C} (I m (s) + 3 σ) \min_{s \in C} (I m (s) - 3 σ)]$ . Сгенерируйте равномерно распределенные символы I/Q по этому пространству и используйте 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

Настройка и Train нейронной сети

Настройте мелкую нейронную сеть с одним входным слоем, одним скрытым слоем и одним выходным слоем. Введите принятый символ в сеть и обучите его для оценки точных значений LLR. Поскольку сеть ожидает реальных входов, создайте два вектора-столбца, где первый столбец является действительными значениями полученного символа, а второй - мнимыми значениями полученного символа. Кроме того, выходы должны быть $k \times N$ вектор, где $k$ количество бит на символ и $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 нейрона, что соответствует количеству бит на символ. Функция llrnetNeuralNetwork возвращает предварительно сконфигурированную нейронную сеть. Обучите нейронную сеть для трех различных значений ОСШ. Используйте точные значения 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. Обратите внимание, что, когда ОСШ увеличивается, это делает значения LLR, что приводит к относительно более высоким значениям MSE.

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

Сравните оценки LLR LLRNet с оценками точных LLR и приблизительных LLR. Симулируйте символы 16-QAM 1e4 и вычислите значения 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, max-log аппроксимации LLR и оценки LLRNet значений LLR в зависимости от действительной части принятого символа для нечетных бит. LLRNet соответствует точным значениям LLR даже для низких значений ОСШ.

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

64-QAM и 256-QAM оценка эффективности LLR

Проверьте, может ли LLRNet оценить значения LLR для QAM более высокого порядка. Повторите тот же процесс, который вы следовали для 16-QAM для 64-QAM и 256-QAM с помощью функции поддержки llrnetQAMLLR. Следующие рисунки показывают точные значения LLR, max-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
    нагрузка ('llrnetQAMPerformanceComparison.mat', 'simResults')
    for p = 1: длина (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. Если установлен Parallel Computing Toolbox™, эта функция использует parfor команда, чтобы запустить параллельные симуляции. На базе процессора Intel ® Xeon ® W-2133 центрального процессора @ 3 с тактовой частотой 6 ГГц и при запуске Кода Run on Parallel Pools (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 (или выберите «Обучить LLRNet» в выпадающем списке), чтобы обучить нейронные сети LLR для каждого значения EsNoValues, для данного subsystemType и numSymbols. Если установлен Toolbox™ Parallel Computing, train функцию можно вызвать с помощью опциональной пары "имя-значение" 'useParallel' установлено на 'yes' чтобы запустить параллельные симуляции. На базе процессора Intel ® Xeon ® W-2133 центрального процессора @ 3 с тактовой частотой 6 ГГц и при запуске Кода Run on Parallel Pools (Parallel Computing Toolbox) с 6 размера симуляция занимает около 21 минут. Задайте trainNow false (или выберите «Использовать сохраненные сети» в выпадающем списке), чтобы загрузить нейронные сети LLR, обученные для subsystemType= '16APSK 2/3', EsNoValues= 8.6:0.1:8.9.

Для получения дополнительной информации о симуляции DVB-S.2 PER смотрите DVB-S.2 Ссылки, Включая кодирование LDPC в примере 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;
        llr Nets = llrnetTrainDVBS2LLRNetwork (subsystem Type, Es No Values, num Train Symbols, hidden Layer Size);
    else
        нагрузка ('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
    нагрузка ('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.

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

llrnetDVBS2PER.m: Моделируйте DVB-S.2 PER с помощью точных LLR, приблизительных LLR и LLRNet LLR
llrnetTrainDVBS2LLRNetwork.m: Обучите нейронные сети для оценки DVB-S.2 LLR
llrnetQAMLLR.m: Обучите нейронные сети для оценки LLR M-арного QAM и вычислите точные LLR, приблизительные LLR и LLRNet LLR
llrnetNeuralNetwork.m: настройте мелкую нейронную сеть для оценки LLR

Ссылки

[1] O. Shental and J. Hoydis «», Machine LLRning «: Learning to Softly Demodulate», 2019 IEEE Globecom Workshops (GC Wkshps), Waikoloa, HI I, USA., 2019, pp. 1-7.

Документация