silas/imdd_silas
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

work on MPI

Browse Source
This commit is contained in:
Silas Oettinghaus
2026-07-13 15:25:45 +02:00
parent a6cf742121
commit ef0a74cb7f
16 changed files with 2894 additions and 705 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
Classes/00_signals/Signal.m
View File

@@ -24,9 +24,9 @@ classdef Signal
obj.signal = signal;
obj.signal = obj.signal;
obj.fs = options.fs;
[~,obj.gitSHA] = system('git rev-parse HEAD');
[~,obj.gitStatus] = system('git status --porcelain');
%
% [~,obj.gitSHA] = system('git rev-parse HEAD');
% [~,obj.gitStatus] = system('git status --porcelain');
% [~,obj.gitPatch] = system('git diff');
%%% Stuff for Logbook %%%

422
Classes/04_DSP/Equalizer/FFE.m
View File

@@ -35,16 +35,19 @@ classdef FFE < handle
% A1 moving-average input suppression
dc_avg_bufferlength_a1
dc_avg_update_blocklength_a1
dc_smoothing_a1
% A2 level-dependent residual suppression
dc_level_avg_bufferlength_a2
dc_level_update_blocklength_a2
dc_smoothing_a2
dc_level_weights_a2
% Adaptive DC-tracking loop
dc_tracking_mu
dc_tracking_adaptive_enabled
dc_tracking_persistence_gain
dc_tracking_power_exponent
dc_tracking_buffer_len
@@ -110,14 +113,17 @@ classdef FFE < handle
options.dd_len_fraction = 1;
options.dc_avg_bufferlength_a1 = 0;
options.dc_avg_update_blocklength_a1 = 0;
options.dc_smoothing_a1 = 0;
options.dc_level_avg_bufferlength_a2 = 0;
options.dc_level_update_blocklength_a2 = 0;
options.dc_smoothing_a2 = 0;
options.dc_level_weights_a2 = 0;
options.dc_tracking_mu = 0;
options.dc_tracking_adaptive_enabled = false;
options.dc_tracking_persistence_gain = 0;
options.dc_tracking_power_exponent = 2;
options.dc_tracking_buffer_len = 1;
@@ -150,15 +156,19 @@ classdef FFE < handle
assert(obj.dc_tracking_buffer_len >= 0);
assert(obj.ffe_update_buffer_len >= 0);
assert(obj.dc_avg_bufferlength_a1 >= 0);
assert(obj.dc_avg_update_blocklength_a1 >= 0);
assert(obj.dc_level_avg_bufferlength_a2 >= 0);
assert(obj.dc_level_update_blocklength_a2 >= 0);
obj.e = zeros(obj.order,1);
obj.e_dc = 0;
obj.error = 0;
obj.a2_level_weight_initial_stats = struct();
obj.dc_avg_bufferlength_a1 = floor(obj.dc_avg_bufferlength_a1);
obj.dc_avg_update_blocklength_a1 = floor(obj.dc_avg_update_blocklength_a1);
obj.dc_smoothing_a1 = min(max(obj.dc_smoothing_a1,0),1);
obj.dc_level_avg_bufferlength_a2 = floor(obj.dc_level_avg_bufferlength_a2);
obj.dc_level_update_blocklength_a2 = floor(obj.dc_level_update_blocklength_a2);
obj.dc_smoothing_a2 = min(max(obj.dc_smoothing_a2,0),1);
obj.dc_tracking_buffer_len = floor(obj.dc_tracking_buffer_len);
obj.ffe_update_buffer_len = floor(obj.ffe_update_buffer_len);
@@ -260,6 +270,24 @@ classdef FFE < handle
x = [zeros(floor(obj.order/2),1); x; zeros(obj.order,1)];
lambda = mu;
n_symbols = ceil(N / obj.sps);
y = zeros(n_symbols,1);
d_hat = zeros(n_symbols,1);
err = zeros(n_symbols,1);
true_err = zeros(n_symbols,1);
constellation = obj.constellation;
if obj.adaption_technique == adaption_method.nlms
adaption_code = 1;
elseif obj.adaption_technique == adaption_method.lms
adaption_code = 2;
elseif obj.adaption_technique == adaption_method.rls
adaption_code = 3;
else
builtin("error","FFE:InvalidAdaptionTechnique", ...
"Unsupported FFE adaption technique.");
end
adaption_is_rls = adaption_code == 3;
if training
mask = ones(obj.order,1);
@@ -280,21 +308,31 @@ classdef FFE < handle
epochs = 1;
end
P_err = 0;
err_prev = 0;
dc_tracking_alpha = obj.dc_tracking_alpha;
dc_tracking_gamma = obj.dc_tracking_gamma;
dc_tracking_mu_min = obj.dc_tracking_mu_min;
dc_tracking_mu_max = obj.dc_tracking_mu_max;
dc_tracking_mu_eff_min = obj.dc_tracking_mu_eff_min;
dc_tracking_mu_eff_max = obj.dc_tracking_mu_eff_max;
dc_tracking_power_exponent = obj.dc_tracking_power_exponent;
dc_buffer_enabled = obj.dc_tracking_mu ~= 0 && obj.dc_tracking_buffer_len > 1;
dc_tracking_persistence_gain = 0;
if obj.dc_tracking_adaptive_enabled
dc_tracking_persistence_gain = obj.dc_tracking_persistence_gain;
end
dc_tracking_enabled = obj.dc_tracking_mu ~= 0;
if dc_tracking_enabled
obj.dc_tracking_mu = min(max(obj.dc_tracking_mu,dc_tracking_mu_min),dc_tracking_mu_max);
end
dc_tracking_mu = obj.dc_tracking_mu;
dc_tracking_use_persistence = dc_tracking_persistence_gain > 0;
dc_tracking_base_mu_eff = min(max(dc_tracking_mu,dc_tracking_mu_eff_min),dc_tracking_mu_eff_max);
dc_buffer_enabled = dc_tracking_enabled && obj.dc_tracking_buffer_len > 1;
if dc_buffer_enabled
e_dc_buffer = NaN(obj.dc_tracking_buffer_len,1);
dc_tracking_err_buffer = NaN(obj.dc_tracking_buffer_len,1);
dc_tracking_err_buffer_pos = 0;
dc_tracking_err_sum = 0;
dc_tracking_abs_err_sum = 0;
dc_tracking_valid_count = 0;
end
ffe_buffer_enabled = obj.ffe_update_buffer_len > 1 && obj.adaption_technique ~= adaption_method.rls;
ffe_buffer_enabled = obj.ffe_update_buffer_len > 1 && ~adaption_is_rls;
if ffe_buffer_enabled
ffe_update_buffer = NaN(obj.order,obj.ffe_update_buffer_len);
end
@@ -303,7 +341,10 @@ classdef FFE < handle
if dc_avg_enabled
dc_avg_buffer_a1 = NaN(obj.dc_avg_bufferlength_a1,1);
dc_avg_est_a1 = 0;
dc_avg_update_blocklength_a1 = obj.dc_avg_bufferlength_a1;
dc_avg_update_blocklength_a1 = obj.dc_avg_update_blocklength_a1;
if dc_avg_update_blocklength_a1 <= 0
dc_avg_update_blocklength_a1 = obj.dc_avg_bufferlength_a1;
end
dc_avg_update_blocklength_a1 = max(1,floor(dc_avg_update_blocklength_a1));
dc_avg_input_offset_a1 = floor(obj.order/2);
% Hardware-like A1 is causal; dc_smoothing_a1 is reserved for offline variants.
@@ -311,12 +352,12 @@ classdef FFE < handle
dc_level_enabled = obj.dc_level_avg_bufferlength_a2 > 1 && any(obj.dc_level_weights_a2(:) ~= 0);
if dc_level_enabled
if isempty(obj.constellation)
if isempty(constellation)
builtin("error","FFE:MissingConstellation", ...
"A2 level-dependent MPI suppression requires obj.constellation to be set.");
end
n_levels = numel(obj.constellation);
n_levels = numel(constellation);
if isscalar(obj.dc_level_weights_a2)
dc_level_weight_by_level = repmat(obj.dc_level_weights_a2,n_levels,1);
elseif numel(obj.dc_level_weights_a2) == n_levels
@@ -325,17 +366,24 @@ classdef FFE < handle
builtin("error","FFE:InvalidDCLevelWeights", ...
"dc_level_weights_a2 must be scalar or have one entry per constellation level.");
end
dc_level_err_buffer = NaN(n_levels,obj.dc_level_avg_bufferlength_a2);
dc_level_buffer_len_a2 = obj.dc_level_avg_bufferlength_a2;
dc_level_err_buffer = NaN(n_levels,dc_level_buffer_len_a2);
dc_level_err_buffer_pos_by_level = zeros(n_levels,1);
dc_level_err_sum_by_level = zeros(n_levels,1);
dc_level_buffer_valid_count_by_level = zeros(n_levels,1);
dc_level_mpi_est_by_level = zeros(n_levels,1);
dc_level_valid_count_by_level = zeros(n_levels,1);
dc_level_update_blocklength_a2 = obj.dc_level_avg_bufferlength_a2;
dc_level_update_blocklength_a2 = obj.dc_level_update_blocklength_a2;
if dc_level_update_blocklength_a2 <= 0
dc_level_update_blocklength_a2 = dc_level_buffer_len_a2;
end
dc_level_update_blocklength_a2 = max(1,floor(dc_level_update_blocklength_a2));
dc_level_window_future_fraction = obj.dc_smoothing_a2; %#ok<NASGU> % reserved for delayed/offline A2 variants
end
debug_enabled = obj.save_debug;
if debug_enabled
n_symbols_debug = ceil(N / obj.sps);
n_symbols_debug = n_symbols;
obj.debug_struct.error = NaN(1,n_symbols_debug);
obj.debug_struct.error_first_epoch = NaN(1,n_symbols_debug);
obj.debug_struct.main_cursor = NaN(1,n_symbols_debug);
@@ -392,15 +440,15 @@ classdef FFE < handle
if training
d_hat(symbol,1) = d(symbol);
if isempty(obj.constellation)
if isempty(constellation)
symbol_idx = NaN;
else
[~,symbol_idx] = min(abs(d_hat(symbol) - obj.constellation));
[~,symbol_idx] = min(abs(d_hat(symbol) - constellation));
end
else
if ~always_ideal_decision
[~,symbol_idx] = min(abs(y(symbol) - obj.constellation)); % decision for closest constellation point
d_hat(symbol,1) = obj.constellation(symbol_idx);
[~,symbol_idx] = min(abs(y(symbol) - constellation)); % decision for closest constellation point
d_hat(symbol,1) = constellation(symbol_idx);
else
d_hat(symbol,1) = d(symbol);
end
@@ -412,26 +460,63 @@ classdef FFE < handle
dc_level_mpi_est = dc_level_mpi_est_by_level(symbol_idx);
dc_level_valid_count = dc_level_valid_count_by_level(symbol_idx);
dc_level_weight = dc_level_weight_by_level(symbol_idx) * ...
min(dc_level_valid_count / obj.dc_level_avg_bufferlength_a2,1);
min(dc_level_valid_count / dc_level_buffer_len_a2,1);
y(symbol,1) = y_raw - dc_level_weight * dc_level_mpi_est;
if training
d_hat(symbol,1) = d(symbol);
else
if ~always_ideal_decision
[~,symbol_idx] = min(abs(y(symbol) - obj.constellation));
d_hat(symbol,1) = obj.constellation(symbol_idx);
[~,symbol_idx] = min(abs(y(symbol) - constellation));
d_hat(symbol,1) = constellation(symbol_idx);
else
d_hat(symbol,1) = d(symbol);
end
end
dc_level_err_buffer(dc_level_symbol_idx,:) = circshift(dc_level_err_buffer(dc_level_symbol_idx,:),1,2);
dc_level_err_buffer(dc_level_symbol_idx,1) = mpi_err;
dc_level_err_buffer_pos = dc_level_err_buffer_pos_by_level(dc_level_symbol_idx) + 1;
if dc_level_err_buffer_pos > dc_level_buffer_len_a2
dc_level_err_buffer_pos = 1;
end
dc_level_err_buffer_pos_by_level(dc_level_symbol_idx) = dc_level_err_buffer_pos;
dc_level_old_err = dc_level_err_buffer(dc_level_symbol_idx,dc_level_err_buffer_pos);
if isfinite(dc_level_old_err)
dc_level_err_sum_by_level(dc_level_symbol_idx) = ...
dc_level_err_sum_by_level(dc_level_symbol_idx) - dc_level_old_err;
dc_level_buffer_valid_count_by_level(dc_level_symbol_idx) = ...
dc_level_buffer_valid_count_by_level(dc_level_symbol_idx) - 1;
end
if isfinite(mpi_err)
dc_level_err_buffer(dc_level_symbol_idx,dc_level_err_buffer_pos) = mpi_err;
dc_level_err_sum_by_level(dc_level_symbol_idx) = ...
dc_level_err_sum_by_level(dc_level_symbol_idx) + mpi_err;
dc_level_buffer_valid_count_by_level(dc_level_symbol_idx) = ...
dc_level_buffer_valid_count_by_level(dc_level_symbol_idx) + 1;
else
dc_level_err_buffer(dc_level_symbol_idx,dc_level_err_buffer_pos) = NaN;
end
if mod(symbol,dc_level_update_blocklength_a2) == 0
dc_level_valid_count_by_level = sum(isfinite(dc_level_err_buffer),2);
dc_level_mpi_est_by_level = mean(dc_level_err_buffer,2,"omitnan");
dc_level_mpi_est_by_level(dc_level_valid_count_by_level == 0) = 0;
if dc_level_update_blocklength_a2 == 1
dc_level_valid_count_by_level(dc_level_symbol_idx) = ...
dc_level_buffer_valid_count_by_level(dc_level_symbol_idx);
if dc_level_valid_count_by_level(dc_level_symbol_idx) == 0
dc_level_mpi_est_by_level(dc_level_symbol_idx) = 0;
else
dc_level_mpi_est_by_level(dc_level_symbol_idx) = ...
dc_level_err_sum_by_level(dc_level_symbol_idx) / ...
dc_level_valid_count_by_level(dc_level_symbol_idx);
end
else
dc_level_valid_count_by_level = dc_level_buffer_valid_count_by_level;
dc_level_has_valid = dc_level_valid_count_by_level > 0;
dc_level_mpi_est_by_level(:) = 0;
dc_level_mpi_est_by_level(dc_level_has_valid) = ...
dc_level_err_sum_by_level(dc_level_has_valid) ./ ...
dc_level_valid_count_by_level(dc_level_has_valid);
end
end
end
@@ -440,10 +525,10 @@ classdef FFE < handle
true_err(symbol) = y(symbol) - d(symbol); % Instantaneous error
if training || obj.dd_mode
switch obj.adaption_technique
if 1 %training || obj.dd_mode
switch adaption_code
case adaption_method.nlms
case 1
% mu used as update weight (suggestion: 0.01-0.05; bit higher during tr)
normU = ((U.'*U)) + eps;
@@ -452,7 +537,7 @@ classdef FFE < handle
update = grad * weight;
case adaption_method.lms
case 2
% mu used as update weight (suggestion: 0.001)
weight = mu;
@@ -461,7 +546,7 @@ classdef FFE < handle
case adaption_method.rls
case 3
% RLS‐Gain:
@@ -486,30 +571,87 @@ classdef FFE < handle
obj.e = obj.e + update;
end
if obj.adaption_technique == adaption_method.rls
if adaption_is_rls
obj.P = (1/lambda) * (obj.P - k * (U.' * obj.P));
end
if obj.dc_tracking_mu ~= 0
if obj.dc_tracking_adaptive_enabled
delta_mu = dc_tracking_gamma * err(symbol) * err_prev * (U.'*U);
obj.dc_tracking_mu = min(max(obj.dc_tracking_mu + delta_mu,dc_tracking_mu_min),dc_tracking_mu_max);
err_prev = err(symbol);
P_err = dc_tracking_alpha*P_err + (1-dc_tracking_alpha)*err(symbol)^2;
dc_tracking_mu_eff = obj.dc_tracking_mu / ((P_err + eps)^dc_tracking_power_exponent);
else
dc_tracking_mu_eff = obj.dc_tracking_mu;
end
dc_tracking_mu_eff = min(max(dc_tracking_mu_eff,dc_tracking_mu_eff_min),dc_tracking_mu_eff_max);
if dc_tracking_enabled
if dc_buffer_enabled
e_dc_buffer(1) = obj.e_dc + dc_tracking_mu_eff * err(symbol);
e_dc_buffer = circshift(e_dc_buffer,1);
dc_tracking_err_buffer_pos = dc_tracking_err_buffer_pos + 1;
if dc_tracking_err_buffer_pos > obj.dc_tracking_buffer_len
dc_tracking_err_buffer_pos = 1;
end
dc_tracking_old_err = dc_tracking_err_buffer(dc_tracking_err_buffer_pos);
if isfinite(dc_tracking_old_err)
dc_tracking_err_sum = dc_tracking_err_sum - dc_tracking_old_err;
dc_tracking_valid_count = dc_tracking_valid_count - 1;
if dc_tracking_use_persistence
dc_tracking_abs_err_sum = dc_tracking_abs_err_sum - abs(dc_tracking_old_err);
end
end
dc_tracking_new_err = err(symbol);
if isfinite(dc_tracking_new_err)
dc_tracking_err_buffer(dc_tracking_err_buffer_pos) = dc_tracking_new_err;
dc_tracking_err_sum = dc_tracking_err_sum + dc_tracking_new_err;
dc_tracking_valid_count = dc_tracking_valid_count + 1;
if dc_tracking_use_persistence
dc_tracking_abs_err_sum = dc_tracking_abs_err_sum + abs(dc_tracking_new_err);
end
else
dc_tracking_err_buffer(dc_tracking_err_buffer_pos) = NaN;
end
if mod(symbol,obj.dc_tracking_buffer_len) == 0
obj.e_dc = mean(e_dc_buffer,"omitnan");
if dc_tracking_valid_count == 0
dc_tracking_err_mean = 0;
if dc_tracking_use_persistence
dc_tracking_err_abs_mean = 0;
end
else
dc_tracking_err_mean = dc_tracking_err_sum / dc_tracking_valid_count;
if dc_tracking_use_persistence
dc_tracking_err_abs_mean = dc_tracking_abs_err_sum / dc_tracking_valid_count;
end
end
if dc_tracking_use_persistence
dc_tracking_persistence_scale = abs(dc_tracking_err_mean) / (dc_tracking_err_abs_mean + eps);
dc_tracking_persistence_scale = min(max(dc_tracking_persistence_scale,0),1);
dc_tracking_mu_eff = dc_tracking_mu * ...
(1 + dc_tracking_persistence_gain * dc_tracking_persistence_scale);
dc_tracking_mu_eff = min(max(dc_tracking_mu_eff,dc_tracking_mu_eff_min),dc_tracking_mu_eff_max);
else
dc_tracking_mu_eff = dc_tracking_base_mu_eff;
end
obj.e_dc = obj.e_dc + dc_tracking_mu_eff * dc_tracking_err_mean;
end
else
obj.e_dc = obj.e_dc + dc_tracking_mu_eff * err(symbol);
dc_tracking_err_mean = err(symbol);
if isfinite(dc_tracking_err_mean)
if dc_tracking_use_persistence
dc_tracking_err_abs_mean = abs(dc_tracking_err_mean);
dc_tracking_persistence_scale = abs(dc_tracking_err_mean) / ...
(dc_tracking_err_abs_mean + eps);
else
dc_tracking_mu_eff = dc_tracking_base_mu_eff;
end
else
dc_tracking_err_mean = 0;
if dc_tracking_use_persistence
dc_tracking_persistence_scale = 0;
else
dc_tracking_mu_eff = dc_tracking_base_mu_eff;
end
end
if dc_tracking_use_persistence
dc_tracking_persistence_scale = min(max(dc_tracking_persistence_scale,0),1);
dc_tracking_mu_eff = dc_tracking_mu * ...
(1 + dc_tracking_persistence_gain * dc_tracking_persistence_scale);
dc_tracking_mu_eff = min(max(dc_tracking_mu_eff,dc_tracking_mu_eff_min),dc_tracking_mu_eff_max);
end
obj.e_dc = obj.e_dc + dc_tracking_mu_eff * dc_tracking_err_mean;
end
end
end
@@ -521,7 +663,7 @@ classdef FFE < handle
if debug_enabled && epoch == epochs
error_power = err(symbol) * err(symbol)';
update_power = update.'*update ./ (rms(obj.e) + eps);
update_power = update.'*update ./ (sqrt((obj.e.'*obj.e) / obj.order) + eps);
obj.debug_struct.error(1,symbol) = error_power;
obj.debug_struct.main_cursor(1,symbol) = abs(obj.e(maincursor_pos));
obj.debug_struct.mu_nlms(1,symbol) = weight;
@@ -611,9 +753,7 @@ classdef FFE < handle
vars = optimizableVariable("dc_tracking_mu",[1e-5,1e-1],"Transform","log");
if obj.dc_tracking_adaptive_enabled
vars = [vars, ...
optimizableVariable("dc_tracking_alpha",[0.85,0.995]), ...
optimizableVariable("dc_tracking_gamma",[1e-7,3e-5],"Transform","log"), ...
optimizableVariable("dc_tracking_power_exponent",[0,2]), ...
optimizableVariable("dc_tracking_persistence_gain",[0,2]), ...
optimizableVariable("dc_tracking_mu_eff_max",[1e-3,3e-1],"Transform","log")];
end
@@ -630,12 +770,10 @@ classdef FFE < handle
best = obj.dc_tracking_optimization.XAtMinObjective;
obj.dc_tracking_mu = best.dc_tracking_mu;
if obj.dc_tracking_adaptive_enabled
obj.dc_tracking_alpha = best.dc_tracking_alpha;
obj.dc_tracking_gamma = best.dc_tracking_gamma;
obj.dc_tracking_power_exponent = best.dc_tracking_power_exponent;
obj.dc_tracking_persistence_gain = best.dc_tracking_persistence_gain;
obj.dc_tracking_mu_eff_max = best.dc_tracking_mu_eff_max;
fprintf("\nFFE DC opt done: dc_tracking_mu=%9.3e, alpha=%6.3f, gamma=%9.3e, p=%5.2f, mu_eff_max=%9.3e, objective=%9.3e\n", ...
obj.dc_tracking_mu,obj.dc_tracking_alpha,obj.dc_tracking_gamma,obj.dc_tracking_power_exponent,obj.dc_tracking_mu_eff_max,obj.dc_tracking_optimization.MinObjective);
fprintf("\nFFE DC opt done: dc_tracking_mu=%9.3e, persistence_gain=%6.3f, mu_eff_max=%9.3e, objective=%9.3e\n", ...
obj.dc_tracking_mu,obj.dc_tracking_persistence_gain,obj.dc_tracking_mu_eff_max,obj.dc_tracking_optimization.MinObjective);
else
fprintf("\nFFE DC opt done: dc_tracking_mu=%9.3e, objective=%9.3e\n", ...
obj.dc_tracking_mu,obj.dc_tracking_optimization.MinObjective);
@@ -668,34 +806,52 @@ classdef FFE < handle
[initial_weights,stats] = obj.a2LevelWeightInitialGuess(x_opt,d_opt);
current_weights = obj.expandA2LevelWeights(n_levels);
initial_matrix = initial_weights(:).';
initial_matrix = [zeros(1,n_levels); initial_weights(:).'];
if any(current_weights ~= 0)
initial_matrix = [initial_matrix; current_weights(:).'];
end
initial_matrix = min(max(initial_matrix,0),obj.a2_level_weight_max);
initial_matrix = unique(initial_matrix,"rows","stable");
initial_x = array2table(initial_matrix,"VariableNames",cellstr(var_names));
[baseline_ber,baseline_errors] = obj.a2LevelWeightBer(initial_x(1,:),x_opt,d_opt);
[x_val,d_val,N_val] = obj.a2ValidationSignals(x,d,N_opt);
stats.baseline_ber = baseline_ber;
stats.baseline_errors = baseline_errors;
obj.a2_level_weight_initial_stats = stats;
obj.a2_level_weight_optimization_iter = 0;
max_evals = max(obj.a2_level_weight_optimization_max_evals,height(initial_x));
fprintf("FFE A2 opt uses fixed mu_tr=%9.3e, mu_dd=%9.3e on %d samples / %d symbols\n", ...
obj.mu_tr,obj.mu_dd,N_opt,numel(d_opt));
fprintf("FFE A2 opt init: var_slope=%9.3e, weights=%s\n", ...
stats.variance_slope,mat2str(initial_weights(:).',3));
fprintf("FFE A2 opt validation uses %d samples / %d symbols\n",N_val,numel(d_val));
fprintf("FFE A2 opt init: baseline BER=%9.3e (%d errors), var_slope=%9.3e, weights=%s\n", ...
baseline_ber,baseline_errors,stats.variance_slope,mat2str(initial_weights(:).',3));
obj.a2_level_weight_optimization = bayesopt(@(p)obj.a2LevelWeightObjective(p,x_opt,d_opt),vars, ...
old_rng = rng;
cleanup_rng = onCleanup(@()rng(old_rng));
rng(42,"twister");
obj.a2_level_weight_optimization = bayesopt(@(p)obj.a2LevelWeightObjective(p,x_opt,d_opt,baseline_ber),vars, ...
"MaxObjectiveEvaluations",max_evals, ...
"InitialX",initial_x, ...
"AcquisitionFunctionName","expected-improvement-plus", ...
"IsObjectiveDeterministic",false, ...
"IsObjectiveDeterministic",true, ...
"Verbose",0, ...
"PlotFcn",[]);
clear cleanup_rng
best = obj.a2_level_weight_optimization.XAtMinObjective;
[best,best_validation_ber,best_validation_errors] = obj.selectA2LevelWeightsByValidation( ...
obj.a2_level_weight_optimization.XTrace, ...
obj.a2_level_weight_optimization.ObjectiveTrace, ...
x_val,d_val,initial_x);
best_opt = obj.a2_level_weight_optimization.XAtMinObjective;
best_opt_weights = obj.a2LevelWeightsFromParams(best_opt);
obj.dc_level_weights_a2 = obj.a2LevelWeightsFromParams(best);
fprintf("\nFFE A2 opt done: weights=%s, BER=%9.3e\n", ...
mat2str(obj.dc_level_weights_a2(:).',3),obj.a2_level_weight_optimization.MinObjective);
obj.a2_level_weight_initial_stats.validation_ber = best_validation_ber;
obj.a2_level_weight_initial_stats.validation_errors = best_validation_errors;
obj.a2_level_weight_initial_stats.validation_weights = obj.dc_level_weights_a2;
fprintf("\nFFE A2 opt done: opt_weights=%s, opt_obj=%9.3e, validation_weights=%s, validation_BER=%9.3e (%d errors)\n", ...
mat2str(best_opt_weights(:).',3),obj.a2_level_weight_optimization.MinObjective, ...
mat2str(obj.dc_level_weights_a2(:).',3),best_validation_ber,best_validation_errors);
end
function [x_opt,d_opt,N_opt] = optimizationSignals(obj,x,d,opt_len)
@@ -719,6 +875,47 @@ classdef FFE < handle
d_opt = d(1:n_symbols);
end
function [x_val,d_val,N_val] = a2ValidationSignals(obj,x,d,N_opt)
N_available = min(numel(x),numel(d) * obj.sps);
N_val = min(N_opt,N_available);
if N_available <= N_opt
[x_val,d_val,N_val] = obj.optimizationSignals(x,d,N_opt);
return
end
start_symbol = floor((N_available - N_val) / obj.sps) + 1;
start_sample = (start_symbol - 1) * obj.sps + 1;
N_val = obj.sps * floor((N_available - start_sample + 1) / obj.sps);
N_val = max(obj.sps,N_val);
n_symbols = N_val / obj.sps;
x_val = x(start_sample:start_sample+N_val-1);
d_val = d(start_symbol:start_symbol+n_symbols-1);
end
function [best_params,best_ber,best_errors] = selectA2LevelWeightsByValidation(obj,x_trace,objective_trace,x_val,d_val,initial_x)
objective_trace = objective_trace(:);
objective_trace(~isfinite(objective_trace)) = inf;
[~,sort_idx] = sort(objective_trace,"ascend");
n_trace_candidates = min(8,numel(sort_idx));
candidate_x = x_trace(sort_idx(1:n_trace_candidates),:);
candidate_x = [initial_x; candidate_x];
candidate_x = unique(candidate_x,"rows","stable");
n_candidates = height(candidate_x);
validation_ber = inf(n_candidates,1);
validation_errors = nan(n_candidates,1);
for candidate_idx = 1:n_candidates
[validation_ber(candidate_idx),validation_errors(candidate_idx)] = ...
obj.a2LevelWeightBer(candidate_x(candidate_idx,:),x_val,d_val);
end
[best_ber,best_idx] = min(validation_ber);
best_errors = validation_errors(best_idx);
best_params = candidate_x(best_idx,:);
fprintf("FFE A2 validation: checked %d candidates, best weights=%s, BER=%9.3e, errors=%d\n", ...
n_candidates,mat2str(obj.a2LevelWeightsFromParams(best_params).',3),best_ber,best_errors);
end
function objective = muObjective(obj,params,x,d)
old_debug = obj.save_debug;
old_dc_tracking_mu = obj.dc_tracking_mu;
@@ -762,7 +959,27 @@ classdef FFE < handle
obj.dc_tracking_mu = old_dc_tracking_mu;
end
function objective = a2LevelWeightObjective(obj,params,x,d)
function objective = a2LevelWeightObjective(obj,params,x,d,baseline_ber)
if nargin < 5 || ~isfinite(baseline_ber)
baseline_ber = inf;
end
[ber,errors] = obj.a2LevelWeightBer(params,x,d);
objective = ber;
if isfinite(baseline_ber)
objective = objective + max(0,ber - baseline_ber);
end
if ~isfinite(objective)
objective = inf;
end
obj.a2_level_weight_optimization_iter = obj.a2_level_weight_optimization_iter + 1;
weights = obj.a2LevelWeightsFromParams(params);
fprintf("\rFFE A2 opt %02d: weights=%s, BER=%9.3e, obj=%9.3e, errors=%d", ...
obj.a2_level_weight_optimization_iter,mat2str(weights(:).',3),ber,objective,errors);
end
function [ber,errors] = a2LevelWeightBer(obj,params,x,d)
state = obj.captureObjectiveState();
cleanup = onCleanup(@()obj.restoreObjectiveState(state));
@@ -782,14 +999,6 @@ classdef FFE < handle
end
[ber,errors] = obj.berObjective(signal,d);
objective = ber;
if ~isfinite(objective)
objective = inf;
end
obj.a2_level_weight_optimization_iter = obj.a2_level_weight_optimization_iter + 1;
fprintf("\rFFE A2 opt %02d: weights=%s, BER=%9.3e, errors=%d", ...
obj.a2_level_weight_optimization_iter,mat2str(obj.dc_level_weights_a2(:).',3),ber,errors);
end
function objective = dcTrackingObjective(obj,params,x,d)
@@ -821,8 +1030,8 @@ classdef FFE < handle
obj.dc_tracking_optimization_iter = obj.dc_tracking_optimization_iter + 1;
if obj.dc_tracking_adaptive_enabled
fprintf("\rFFE DC opt %02d: dc_tracking_mu=%9.3e, alpha=%6.3f, gamma=%9.3e, p=%5.2f, mu_eff_max=%9.3e, BER=%9.3e, delay=%7.0f, corr=%6.3f, obj=%9.3e, errors=%d", ...
obj.dc_tracking_optimization_iter,params.dc_tracking_mu,params.dc_tracking_alpha,params.dc_tracking_gamma,params.dc_tracking_power_exponent,params.dc_tracking_mu_eff_max, ...
fprintf("\rFFE DC opt %02d: dc_tracking_mu=%9.3e, persistence_gain=%6.3f, mu_eff_max=%9.3e, BER=%9.3e, delay=%7.0f, corr=%6.3f, obj=%9.3e, errors=%d", ...
obj.dc_tracking_optimization_iter,params.dc_tracking_mu,params.dc_tracking_persistence_gain,params.dc_tracking_mu_eff_max, ...
ber,delay_symbols,delay_corr,objective,errors);
else
fprintf("\rFFE DC opt %02d: dc_tracking_mu=%9.3e, BER=%9.3e, delay=%7.0f, corr=%6.3f, obj=%9.3e, errors=%d", ...
@@ -835,14 +1044,8 @@ classdef FFE < handle
if any(var_names == "dc_tracking_mu")
obj.dc_tracking_mu = params.dc_tracking_mu;
end
if any(var_names == "dc_tracking_alpha")
obj.dc_tracking_alpha = params.dc_tracking_alpha;
end
if any(var_names == "dc_tracking_gamma")
obj.dc_tracking_gamma = params.dc_tracking_gamma;
end
if any(var_names == "dc_tracking_power_exponent")
obj.dc_tracking_power_exponent = params.dc_tracking_power_exponent;
if any(var_names == "dc_tracking_persistence_gain")
obj.dc_tracking_persistence_gain = params.dc_tracking_persistence_gain;
end
if any(var_names == "dc_tracking_mu_eff_max")
obj.dc_tracking_mu_eff_max = params.dc_tracking_mu_eff_max;
@@ -950,6 +1153,51 @@ classdef FFE < handle
"initial_weights",weights);
end
function [e_dc_next,stats] = dcTrackingBlockUpdate(obj,e_dc_current,err_block,options)
arguments
obj
e_dc_current (1,1) double
err_block (:,1) double
options.mu_dc (1,1) double = NaN
options.persistence_gain (1,1) double = 0
options.mu_eff_min (1,1) double = NaN
options.mu_eff_max (1,1) double = NaN
end
if isnan(options.mu_dc)
options.mu_dc = obj.dc_tracking_mu;
end
if isnan(options.mu_eff_min)
options.mu_eff_min = obj.dc_tracking_mu_eff_min;
end
if isnan(options.mu_eff_max)
options.mu_eff_max = obj.dc_tracking_mu_eff_max;
end
valid_err = err_block(isfinite(err_block));
if isempty(valid_err)
err_mean = 0;
err_abs_mean = 0;
else
err_mean = mean(valid_err,"omitnan");
err_abs_mean = mean(abs(valid_err),"omitnan");
end
persistence_scale = abs(err_mean) / (err_abs_mean + eps);
persistence_scale = min(max(persistence_scale,0),1);
mu_eff = options.mu_dc * (1 + max(options.persistence_gain,0) * persistence_scale);
mu_eff = min(max(mu_eff,options.mu_eff_min),options.mu_eff_max);
update = mu_eff * err_mean;
e_dc_next = e_dc_current + update;
stats = struct( ...
"err_mean",err_mean, ...
"err_abs_mean",err_abs_mean, ...
"persistence_scale",persistence_scale, ...
"mu_eff",mu_eff, ...
"update",update);
end
function state = captureObjectiveState(obj)
state.e = obj.e;
state.e_dc = obj.e_dc;
@@ -959,6 +1207,7 @@ classdef FFE < handle
state.dc_tracking_mu = obj.dc_tracking_mu;
state.dc_tracking_alpha = obj.dc_tracking_alpha;
state.dc_tracking_gamma = obj.dc_tracking_gamma;
state.dc_tracking_persistence_gain = obj.dc_tracking_persistence_gain;
state.dc_tracking_power_exponent = obj.dc_tracking_power_exponent;
state.dc_tracking_mu_eff_max = obj.dc_tracking_mu_eff_max;
state.dc_level_weights_a2 = obj.dc_level_weights_a2;
@@ -974,6 +1223,7 @@ classdef FFE < handle
obj.dc_tracking_mu = state.dc_tracking_mu;
obj.dc_tracking_alpha = state.dc_tracking_alpha;
obj.dc_tracking_gamma = state.dc_tracking_gamma;
obj.dc_tracking_persistence_gain = state.dc_tracking_persistence_gain;
obj.dc_tracking_power_exponent = state.dc_tracking_power_exponent;
obj.dc_tracking_mu_eff_max = state.dc_tracking_mu_eff_max;
obj.dc_level_weights_a2 = state.dc_level_weights_a2;
@@ -989,8 +1239,8 @@ classdef FFE < handle
rx_bits = mapper.demap(eq_signal_hd);
tx_bits = mapper.demap(tx_symbols);
[~,errors,ber,~] = calc_ber(rx_bits.signal,tx_bits.signal, ...
"skip_front",10, ...
"skip_end",10, ...
"skip_front",1000, ...
"skip_end",0, ...
"returnErrorLocation",1);
end