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

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

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

Большинство современных систем связи, таких как Новое радио (NR) 5G и Цифровое телевидение для Спутника, Второе поколение (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-bit, и $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}$ шумовое отклонение. Экспоненциальные и логарифмические вычисления являются очень дорогостоящими особенно во встраиваемых системах. Поэтому самые практические системы используют приближение макс. журнала. Для данного массива $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, журнал Max аппроксимированный LLR и LLRNet для m-арного QAM

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

Точный LLR
Журнал Max аппроксимированный 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

Настройте и Обучите Нейронную сеть

Настройте мелкую нейронную сеть с одним входным слоем, одним скрытым слоем и одним выходным слоем. Введите полученный символ к сети и обучите ее оценивать точные значения LLR. Поскольку сеть ожидает действительные входные параметры, создайте два вектор-столбца, где первый столбец является действительными значениями полученного символа, и второй столбец является мнимыми значениями полученного символа. Кроме того, выход должен быть a $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.43
Starting parallel pool (parpool) using the 'local' profile ...
Connected to the parallel pool (number of workers: 12).
		Trial 1: MSE = 7.44e-05
		Trial 2: MSE = 6.90e-05
		Trial 3: MSE = 6.81e-05
	Best MSE = 6.81e-05
Training neural network for SNR = 0.0dB
	Mean Square LLR = 15.74
		Trial 1: MSE = 1.86e-03
		Trial 2: MSE = 4.04e-04
		Trial 3: MSE = 9.05e-05
	Best MSE = 9.05e-05
Training neural network for SNR = 5.0dB
	Mean Square LLR = 60.01
		Trial 1: MSE = 8.59e-03
		Trial 2: MSE = 2.19e-02
		Trial 3: MSE = 2.14e-02
	Best MSE = 8.59e-03

Показатель производительности для этой сети является среднеквадратичной погрешностью (MSE). Итоговые значения MSE показывают, что нейронная сеть сходится к значению MSE, которое составляет по крайней мере 40 дБ меньше, чем среднеквадратические точные значения LLR. Обратите внимание на то, что, в то время как ОСШ увеличивается также - значения 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, макс. журнал аппроксимируют 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, макс. журнал аппроксимируют LLR и оценку LLRNet значений LLR по сравнению с действительной частью полученного символа для нечетных битов.

trainNow = false;
if trainNow
    % Parameters for 64-QAM
    simParams (1) М = 64; %#ok<UNRCH>
    simParams (1).SNRValues = 0:5:10;
    simParams (1).HiddenLayerSize = 16;
    simParams (1).NumSymbols = 1e4;
    simParams (1).UseReLU = ложь;
    
    % Parameters for 256-QAM
    simParams (2) М = 256;
    simParams (2).SNRValues = 0:10:20;
    simParams (2).HiddenLayerSize = 32;
    simParams (2).NumSymbols = 1e4;
    simParams (2).UseReLU = ложь;
    
    simResults = llrnetQAMLLR (simParams);
    llrnetPlotLLR (simResults (1), sprintf ('%d-QAM LLR Comparison', simResults (1) М))
    llrnetPlotLLR (simResults (2), sprintf ('%d-QAM LLR Comparison', simResults (2) М))
else
    загрузка'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 к истинному (или выбирают "Simulate" в выпадающем) запускать симуляции PER для значений subsystemType, EsNoValues, и numSymbols использование функции llrnetDVBS2PER. Если Parallel Computing Toolbox™ установлен, эта функция использует parfor команда, чтобы запустить параллельные симуляции. На центральном процессоре Intel® Xeon® W-2133 3.6 ГГц и выполнении Кода Запуска по Параллельным Пулам (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. Если Parallel Computing Toolbox™ установлен, train функция может быть вызвана с дополнительной парой "имя-значение" 'useParallel' установите на 'yes' запускать параллельные симуляции. На центральном процессоре Intel® Xeon® W-2133 3.6 ГГц и выполнении Кода Запуска по Параллельным Пулам (Parallel Computing Toolbox) размера 6, симуляция занимает приблизительно 21 минуту. Установите trainNow ко лжи (или выбирают "Use saved networks" в выпадающем) загружать нейронные сети LLR, обученные для subsystemType='16APSK 2/3', EsNoValues=8.6:0.1:8.9.

Для получения дополнительной информации о симуляции PER DVB-S.2 смотрите Ссылку DVB-S.2, Включая LDPC Кодирование примера. Для получения дополнительной информации об обучении сети обратитесь к функции 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
        загрузка'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, Включая LDPC Кодирование примера. Можно также попробовать различные размеры за скрытый слой сети, чтобы сократить количество операций и измерить потерю производительности по сравнению с точным LLR.

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

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

Ссылки

[1] Shental, Ори и Джэйкоб Хойдис. “‘Машина LLRning’: обучение мягко демодулировать”. ArXiv:1907.01512 [Cs, математика], июль 2019. arXiv.org, http://arxiv.org/abs/1907.01512.

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