MSP估计算法

最新推荐文章于 2023-01-14 18:00:00 发布
最新推荐文章于 2023-01-14 18:00:00 发布
阅读量4.1k 收藏 3
点赞数 1
分类专栏： MATLAB 板块2:图像-特征提取处理 板块1:通信与信号处理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ccsss22/article/details/111350392
版权


clc;
clear;
close all;
warning off;

%% 
%--------------------------------------------------------------------------------
%
%            Different information measures comparison
%
%--------------------------------------------------------------------------------
%
% This script generates:
% - noise level estimates for Rayleigh distributed data for different
% information measures, i.e., J-divergence, Renyi's divergence, Vajda's measure
% - plots estimators' bias, variance and mean square error (MSE)
%--------------------------------------------------------------------------
%
% (!!!) Before running this script:
% - set appropriate 'iterations' value, e.g., iterations = 1000;
% - set appropriate 'source_path' value
%
%-----------------------------  PATHS  -----------------------------------
%addpath('plot2svg');
%addpath('DataIO');
addpath('MSP');
addpath('QuantitativeMeasures');
addpath('ReferenceMethods');

%---------------------  SIMULATION PARAMETERS  ---------------------------
% simulation
iterations = 100; % iterations
sigma_vector = 5:5:50; % noise levels

% numerical optimization properties (gradient descent method)
sigma0 = 10;
step_size = 5;
max_iter = 100;
max_tolerance = 1e-3;
delta = 0;

% Read real raw data 
%ReadData_Transverse   %  (!!!)  CONNECT TO YOUR OWN DATA

% Temporary handle artificial data - COMMENT HERE
dataset_re = zeros(217, 181);     % real part of the MRI image
dataset_im = zeros(217, 181);     % imaginary part of the MRI image

mask_T1_1mm_bg = zeros(217, 181); % background mask of the MRI image - PUT YOUR MASK HERE
mask_T1_1mm_bg(50:150, 50:100) = 1; % artificial background mask

%% Rayleigh distribution (background data)
Rayleigh_MSP_results_GD_KL1 = zeros(iterations, length(sigma_vector));         % Kullback-Leibler divergence, k = 1
Rayleigh_MSP_results_GD_KL2 = zeros(iterations, length(sigma_vector));         % Kullback-Leibler divergence, k = 4

Rayleigh_MSP_results_GD_Jeffreys1 = zeros(iterations, length(sigma_vector));   % J-divergence, k = 1
Rayleigh_MSP_results_GD_Jeffreys2 = zeros(iterations, length(sigma_vector));   % J-divergence, k = 4
 
Rayleigh_MSP_results_GD_Renyi1 = zeros(iterations, length(sigma_vector));      % Renyi, k = 1, p = 1/2
%Rayleigh_MSP_results_GD_Renyi2 = zeros(iterations, length(sigma_vector));     % Renyi, k = 1, p = 2
Rayleigh_MSP_results_GD_Renyi3 = zeros(iterations, length(sigma_vector));      % Renyi, k = 4, p = 2

%Rayleigh_MSP_results_NM_Vajda1 = zeros(iterations, length(sigma_vector));     % Vajda, k = 1, p = 1
Rayleigh_MSP_results_NM_Vajda2 = zeros(iterations, length(sigma_vector));      % Vajda, k = 1, p = 2
%Rayleigh_MSP_results_NM_Vajda3 = zeros(iterations, length(sigma_vector));     % Vajda, k = 4, p = 2


FUNCTION_HANDLE_MSP_RAYLEIGH_KL = @(sigma_, m_, k_, delta_, weights_)MSP_Rayleigh_distribution(sigma_, m_, k_, delta_, weights_);
FUNCTION_HANDLE_MSP_RAYLEIGH_JEFFREYS = @(sigma_, m_, k_, delta_, weights_)MSP_Rayleigh_distribution_Jeffreys_Divergence(sigma_, m_, k_, delta_, weights_);
FUNCTION_HANDLE_MSP_RAYLEIGH_RENYI = @(sigma_, m_, k_, delta_, weights_)MSP_Rayleigh_distribution_Renyi_Divergence(sigma_, m_, k_, delta_, weights_);
%-----------------------------------------------------------------------------                                            

for iter=1:iterations
     for noise_level=1:length(sigma_vector)

        sigma = sigma_vector(noise_level);

        % Noise in magnitude
        dataset_noise1 = random('norm', 0, sigma, size(dataset_re, 1), size(dataset_re, 2));
        dataset_noise2 = random('norm', 0, sigma, size(dataset_im, 1), size(dataset_im, 2));
        
        dataset_T1_1mm_noisy = sqrt( (dataset_re + dataset_noise1).^2 + (dataset_im  + dataset_noise2).^2 );

        data = dataset_T1_1mm_noisy .* mask_T1_1mm_bg;
        data = data(:);
        data = data(data > 0);
        data = sort(data);
             
        
        % ------------------------------- Individual information measures ------------------------------         
        % Kullback-Leibler (gradient descent optimization method) - k = 1  - KULLBACK-LEIBLER DIVERGENCE
        [sigma_MSP_GD_KL1, function_value_MSP_GD_KL1] = Optimization_Rayleigh_GD(FUNCTION_HANDLE_MSP_RAYLEIGH_KL, sigma0, data, 1, delta, step_size, max_iter, max_tolerance, 0);                  

        % Kullback-Leibler (gradient descent optimization method) - k = 4  - KULLBACK-LEIBLER DIVERGENCE
        [sigma_MSP_GD_KL2, function_value_MSP_GD_KL2] = Optimization_Rayleigh_GD(FUNCTION_HANDLE_MSP_RAYLEIGH_KL, sigma0, data, 4, delta, step_size, max_iter, max_tolerance, 0);        
        
        %-----------------------------------------------------------------------------------
        
        % J-divergence (gradient descent optimization method) - k = 1  - J-DIVERGENCE
        [sigma_MSP_GD_Jeffreys1, function_value_MSP_GD_Jeffreys1] = Optimization_Rayleigh_GD(FUNCTION_HANDLE_MSP_RAYLEIGH_JEFFREYS, sigma0, data, 1, delta, step_size, max_iter, max_tolerance, 0);

        % J-divergence (gradient descent optimization method) - k = 4  - J-DIVERGENCE
        [sigma_MSP_GD_Jeffreys2, function_value_MSP_GD_Jeffreys2] = Optimization_Rayleigh_GD(FUNCTION_HANDLE_MSP_RAYLEIGH_JEFFREYS, sigma0, data, 4, delta, step_size, max_iter, max_tolerance, 0);
        %-----------------------------------------------------------------------------------                
                
             
        %-----------------------------------------------------------------------------------                
        % Renyi divergence (Nelder-Mead optimization method) - k = 1, p = 1/2  - RENYI'S DIVERGENCE
        %[sigma_MSP_GD_Renyi1, function_value_MSP_GD_Renyi1] = Optimization_Rayleigh_GD(FUNCTION_HANDLE_MSP_RAYLEIGH_RENYI, sigma0, data, 1, delta, step_size, max_iter, max_tolerance, 0.5);     
        n = length(data);     k = 1;      p = 1/2;        
        beta = (n+1)/k;
        RENYI1 = @(sigma) ( -((sign(1-p) * beta^p)/(n-k+2)) .* ( (1 -  exp(-(data(k).^2) ./ (2*sigma^2)))^p    +      sum((exp(-(data(1:n-k).^2) ./ (2*sigma^2)) - exp(-(data(k+1:n).^2) ./ (2*sigma^2))).^p)       +      exp(-(data(n-k+1).^2) ./ (2*sigma^2))^p));
        sigma_MSP_GD_Renyi1 = fminsearch(RENYI1, sigma0);
        %-----------------------------------------------------------------------------------                        
        
        
        %-----------------------------------------------------------------------------------                
        % Renyi divergence (Nelder-Mead optimization method) - k = 4, p = 2  - RENYI'S DIVERGENCE
        %[sigma_MSP_GD_Renyi3, function_value_MSP_GD_Renyi3] = Optimization_Rayleigh_GD(FUNCTION_HANDLE_MSP_RAYLEIGH_RENYI, sigma0, data, 4, delta, step_size, max_iter, max_tolerance, 2);            
        n = length(data);       k = 4;        p = 2;
        beta = (n+1)/k;        
        RENYI3 = @(sigma) ( -((sign(1-p) * beta^p)/(n-k+2)) .* ( (1 -  exp(-(data(k).^2) ./ (2*sigma^2)))^p    +      sum((exp(-(data(1:n-k).^2) ./ (2*sigma^2)) - exp(-(data(k+1:n).^2) ./ (2*sigma^2))).^p)       +      exp(-(data(n-k+1).^2) ./ (2*sigma^2))^p));
        sigma_MSP_GD_Renyi3 = fminsearch(RENYI3, sigma0);
        %-----------------------------------------------------------------------------------                
        
                
        %-----------------------------------------------------------------------------------                
        % Vajda's measure (Nelder-Mead optimization method) - k = 1, p = 2
        n = length(data);  k = 1;   p = 2;
        beta = (n+1)/k;             
        VAJDA2 = @(sigma) ( (1/(n-k+2)) .* (  abs( 1 - beta*(1 - exp(-(data(k).^2) ./ (2*sigma^2)) ) )^p   +  sum(  ( abs(1 - beta*(exp(-(data(1:n-k).^2) ./ (2*sigma^2)) - exp(-(data(k+1:n).^2) ./ (2*sigma^2)))  ) ).^p  )   +   (abs(1 - beta*exp(-(data(n-k+1).^2) ./ (2*sigma^2))))^p  ) );        
        sigma_MSP_NM_Vajda2 = fminsearch(VAJDA2, sigma0);        
        %-----------------------------------------------------------------------------------                        
        
        
        % store results in arrays
        Rayleigh_MSP_results_GD_KL1(iter, noise_level) = sigma_MSP_GD_KL1;  
        Rayleigh_MSP_results_GD_KL2(iter, noise_level) = sigma_MSP_GD_KL2;                
        Rayleigh_MSP_results_GD_Jeffreys1(iter, noise_level) = sigma_MSP_GD_Jeffreys1;  
        Rayleigh_MSP_results_GD_Jeffreys2(iter, noise_level) = sigma_MSP_GD_Jeffreys2;                
        Rayleigh_MSP_results_GD_Renyi1(iter, noise_level) = sigma_MSP_GD_Renyi1;
        Rayleigh_MSP_results_GD_Renyi3(iter, noise_level) = sigma_MSP_GD_Renyi3;                 
        Rayleigh_MSP_results_NM_Vajda2(iter, noise_level) = sigma_MSP_NM_Vajda2;                

    end
    
    fprintf('%.1f %%\n', (iter/iterations)*100);    
end


% bias(sigma_hat)
MSP_GD_vector_mean_bias_KL1 = zeros(1, length(sigma_vector));
MSP_GD_vector_mean_bias_KL2 = zeros(1, length(sigma_vector));
MSP_GD_vector_mean_bias_Jeffreys1 = zeros(1, length(sigma_vector));
MSP_GD_vector_mean_bias_Jeffreys2 = zeros(1, length(sigma_vector));
MSP_GD_vector_mean_bias_Renyi1 = zeros(1, length(sigma_vector));
MSP_GD_vector_mean_bias_Renyi3 = zeros(1, length(sigma_vector));
MSP_NM_vector_mean_bias_Vajda2 = zeros(1, length(sigma_vector));

% variance(sigma_hat) 
MSP_GD_vector_mean_var_KL1 = zeros(1, length(sigma_vector));
MSP_GD_vector_mean_var_KL2 = zeros(1, length(sigma_vector));
MSP_GD_vector_mean_var_Jeffreys1 = zeros(1, length(sigma_vector));
MSP_GD_vector_mean_var_Jeffreys2 = zeros(1, length(sigma_vector));
MSP_GD_vector_mean_var_Renyi1 = zeros(1, length(sigma_vector));
MSP_GD_vector_mean_var_Renyi3 = zeros(1, length(sigma_vector));
MSP_NM_vector_mean_var_Vajda2 = zeros(1, length(sigma_vector));

% mse(sigma_hat)
MSP_GD_vector_mean_mse_KL1 = zeros(1, length(sigma_vector));
MSP_GD_vector_mean_mse_KL2 = zeros(1, length(sigma_vector));
MSP_GD_vector_mean_mse_Jeffreys1 = zeros(1, length(sigma_vector));
MSP_GD_vector_mean_mse_Jeffreys2 = zeros(1, length(sigma_vector));
MSP_GD_vector_mean_mse_Renyi1 = zeros(1, length(sigma_vector));
MSP_GD_vector_mean_mse_Renyi3 = zeros(1, length(sigma_vector));
MSP_NM_vector_mean_mse_Vajda2 = zeros(1, length(sigma_vector));


for k=1:length(sigma_vector) 
    % bias(sigma) = E(sigma_hat) - sigma
    MSP_GD_vector_mean_bias_KL1(k) = mean(Rayleigh_MSP_results_GD_KL1(:,k)) - sigma_vector(k);    
    MSP_GD_vector_mean_bias_KL2(k) = mean(Rayleigh_MSP_results_GD_KL2(:,k)) - sigma_vector(k);
    MSP_GD_vector_mean_bias_Jeffreys1(k) = mean(Rayleigh_MSP_results_GD_Jeffreys1(:,k)) - sigma_vector(k);    
    MSP_GD_vector_mean_bias_Jeffreys2(k) = mean(Rayleigh_MSP_results_GD_Jeffreys2(:,k)) - sigma_vector(k);    
    MSP_GD_vector_mean_bias_Renyi1(k) = mean(Rayleigh_MSP_results_GD_Renyi1(:,k)) - sigma_vector(k);        
    MSP_GD_vector_mean_bias_Renyi3(k) = mean(Rayleigh_MSP_results_GD_Renyi3(:,k)) - sigma_vector(k);            
    MSP_NM_vector_mean_bias_Vajda2(k) = mean(Rayleigh_MSP_results_NM_Vajda2(:,k)) - sigma_vector(k);                              
    
    % variance(sigma_hat) = E(sigma_hat^2) - E^2(sigma_hat)
    MSP_GD_vector_mean_var_KL1(k) = mean(Rayleigh_MSP_results_GD_KL1(:,k).^2) - mean(Rayleigh_MSP_results_GD_KL1(:,k)).^2;
    MSP_GD_vector_mean_var_KL2(k) = mean(Rayleigh_MSP_results_GD_KL2(:,k).^2) - mean(Rayleigh_MSP_results_GD_KL2(:,k)).^2;
    MSP_GD_vector_mean_var_Jeffreys1(k) = mean(Rayleigh_MSP_results_GD_Jeffreys1(:,k).^2) - mean(Rayleigh_MSP_results_GD_Jeffreys1(:,k)).^2;
    MSP_GD_vector_mean_var_Jeffreys2(k) = mean(Rayleigh_MSP_results_GD_Jeffreys2(:,k).^2) - mean(Rayleigh_MSP_results_GD_Jeffreys2(:,k)).^2;
    MSP_GD_vector_mean_var_Renyi1(k) = mean(Rayleigh_MSP_results_GD_Renyi1(:,k).^2) - mean(Rayleigh_MSP_results_GD_Renyi1(:,k)).^2;
    MSP_GD_vector_mean_var_Renyi3(k) = mean(Rayleigh_MSP_results_GD_Renyi3(:,k).^2) - mean(Rayleigh_MSP_results_GD_Renyi3(:,k)).^2;
    MSP_NM_vector_mean_var_Vajda2(k) = mean(Rayleigh_MSP_results_NM_Vajda2(:,k).^2) - mean(Rayleigh_MSP_results_NM_Vajda2(:,k)).^2;
    
    % MSE(sigma) = bias(sigma)^2 + variance(sigma_hat)
    MSP_GD_vector_mean_mse_KL1(k) = ImageRMSE(Rayleigh_MSP_results_GD_KL1(:,k), sigma_vector(k) .* ones(size(Rayleigh_MSP_results_GD_KL1(:,k))), ones(size(Rayleigh_MSP_results_GD_KL1(:,k))));    
    MSP_GD_vector_mean_mse_KL2(k) = ImageRMSE(Rayleigh_MSP_results_GD_KL2(:,k), sigma_vector(k) .* ones(size(Rayleigh_MSP_results_GD_KL2(:,k))), ones(size(Rayleigh_MSP_results_GD_KL2(:,k))));
    MSP_GD_vector_mean_mse_Jeffreys1(k) = ImageRMSE(Rayleigh_MSP_results_GD_Jeffreys1(:,k), sigma_vector(k) .* ones(size(Rayleigh_MSP_results_GD_Jeffreys1(:,k))), ones(size(Rayleigh_MSP_results_GD_Jeffreys1(:,k))));    
    MSP_GD_vector_mean_mse_Jeffreys2(k) = ImageRMSE(Rayleigh_MSP_results_GD_Jeffreys2(:,k), sigma_vector(k) .* ones(size(Rayleigh_MSP_results_GD_Jeffreys2(:,k))), ones(size(Rayleigh_MSP_results_GD_Jeffreys2(:,k))));
    MSP_GD_vector_mean_mse_Renyi1(k) = ImageRMSE(Rayleigh_MSP_results_GD_Renyi1(:,k), sigma_vector(k) .* ones(size(Rayleigh_MSP_results_GD_Renyi1(:,k))), ones(size(Rayleigh_MSP_results_GD_Renyi1(:,k))));
    MSP_GD_vector_mean_mse_Renyi3(k) = ImageRMSE(Rayleigh_MSP_results_GD_Renyi3(:,k), sigma_vector(k) .* ones(size(Rayleigh_MSP_results_GD_Renyi3(:,k))), ones(size(Rayleigh_MSP_results_GD_Renyi3(:,k))));    
    MSP_NM_vector_mean_mse_Vajda2(k) = ImageRMSE(Rayleigh_MSP_results_NM_Vajda2(:,k), sigma_vector(k) .* ones(size(Rayleigh_MSP_results_NM_Vajda2(:,k))), ones(size(Rayleigh_MSP_results_NM_Vajda2(:,k))));    
end  

%---------------------------- mean bias(sigma_hat) --------------------------
figure,
hold on  
plot(sigma_vector, MSP_GD_vector_mean_bias_KL1, '^-', 'Color', [49/255, 57/255, 174/255], 'LineWidth', 1.5, 'MarkerSize', 11);
plot(sigma_vector, MSP_GD_vector_mean_bias_KL2, '>-', 'Color', [221/255 42/255 43/255], 'LineWidth', 1.5, 'MarkerSize', 11)
plot(sigma_vector, MSP_GD_vector_mean_bias_Jeffreys1, 'd-', 'Color', [0 0.6 0.2], 'LineWidth', 1.5, 'MarkerSize', 12);
plot(sigma_vector, MSP_GD_vector_mean_bias_Renyi1, 's-', 'Color', [0 0 0], 'LineWidth', 1.5, 'MarkerSize', 9);
plot(sigma_vector, MSP_GD_vector_mean_bias_Renyi3, 'x-', 'Color', [115/255 130/255 179/255], 'LineWidth', 1.5, 'MarkerSize', 13);
plot(sigma_vector, MSP_NM_vector_mean_bias_Vajda2, 'o-', 'Color', [255/255 165/255 0], 'LineWidth', 1.5, 'MarkerSize', 11);
legend('Kullback-Leibler divergence (k=1)', 'Kullback-Leibler divergence (k=4)', 'J-divergence (k=1)', 'Renyi divergence (k=1, p=0.5)', 'Renyi divergence (k=4, p=2)', 'Vajda''s measure (k=1, p=2)', 'location', 'NorthEast'); 
grid on
hold off
xlabel('Noise level \sigma');
ylabel('Bias(\sigma)');
text_size = 16;
set(gca, 'FontSize', text_size);
set(get(gca,'xlabel'), 'FontSize', text_size);
set(get(gca,'ylabel'), 'FontSize', text_size);
%set(gca,'YTick', -0.1:0.1:0.9);
%axis([5, 50, -0.1, 0.9]);
%plot2svg('bias_different_measures.svg', 1);

%------------------------ variance(sigma) ----------------------------------------------
sigma_CRLB = linspace(sigma_vector(1), sigma_vector(length(sigma_vector)), 1000);
CRLB = sigma_CRLB.^2 / (4 * length(data));
figure,
hold on
plot(sigma_CRLB, CRLB, '--', 'Color', [0 0 0], 'LineWidth', 2.5);
plot(sigma_vector, MSP_GD_vector_mean_var_KL1, '^-', 'Color', [49/255, 57/255, 174/255], 'LineWidth', 1.5, 'MarkerSize', 11);
plot(sigma_vector, MSP_GD_vector_mean_var_KL2, '>-', 'Color', [221/255 42/255 43/255], 'LineWidth', 1.5, 'MarkerSize', 11)
plot(sigma_vector, MSP_GD_vector_mean_var_Jeffreys1, 'd-', 'Color', [0 0.6 0.2], 'LineWidth', 1.5, 'MarkerSize', 12);
plot(sigma_vector, MSP_GD_vector_mean_var_Renyi1, 's-', 'Color', [0 0 0], 'LineWidth', 1.5, 'MarkerSize', 9);
plot(sigma_vector, MSP_GD_vector_mean_var_Renyi3, 'x-', 'Color', [115/255 130/255 179/255], 'LineWidth', 1.5, 'MarkerSize', 13);
plot(sigma_vector, MSP_NM_vector_mean_var_Vajda2, 'o-', 'Color', [255/255 165/255 0], 'LineWidth', 1.5, 'MarkerSize', 11);
hold off
grid on
xlabel('Noise level \sigma');
ylabel('Variance(\sigma)');
legend('CRLB_\sigma(\sigma)');
text_size = 16;
set(gca, 'FontSize', text_size);
set(get(gca,'xlabel'), 'FontSize', text_size);
set(get(gca,'ylabel'), 'FontSize', text_size);
%axis([5, 50, 0, 0.11]);
%set(gca,'YTick', 0:0.01:0.11);
%plot2svg('variance_different_measures.svg', 2);

%----------------------- MSE(sigma) -----------------------------------------------------
figure,
hold on
plot(sigma_vector, MSP_GD_vector_mean_mse_KL1, '^-', 'Color', [49/255, 57/255, 174/255], 'LineWidth', 1.5, 'MarkerSize', 11);
plot(sigma_vector, MSP_GD_vector_mean_mse_KL2, '>-', 'Color', [221/255 42/255 43/255], 'LineWidth', 1.5, 'MarkerSize', 11)
plot(sigma_vector, MSP_GD_vector_mean_mse_Jeffreys1, 'd-', 'Color', [0 0.6 0.2], 'LineWidth', 1.5, 'MarkerSize', 12);
plot(sigma_vector, MSP_GD_vector_mean_mse_Renyi1, 's-', 'Color', [0 0 0], 'LineWidth', 1.5, 'MarkerSize', 9);
plot(sigma_vector, MSP_GD_vector_mean_mse_Renyi3, 'x-', 'Color', [115/255 130/255 179/255], 'LineWidth', 1.5, 'MarkerSize', 13);
plot(sigma_vector, MSP_NM_vector_mean_mse_Vajda2, 'o-', 'Color', [255/255 165/255 0], 'LineWidth', 1.5, 'MarkerSize', 11);
legend('Kullback-Leibler divergence (k=1)', 'Kullback-Leibler divergence (k=4)', 'J-divergence (k=1)', 'Renyi divergence (k=1, p=0.5)', 'Renyi divergence (k=4, p=2)', 'Vajda''s measure (k=1, p=2)', 'location', 'NorthEast'); 
grid on 
hold off
xlabel('Noise level \sigma');
ylabel('MSE(\sigma)');
text_size = 16;
set(gca, 'FontSize', text_size);
set(get(gca,'xlabel'), 'FontSize', text_size);
set(get(gca,'ylabel'), 'FontSize', text_size);
%axis([5, 50, 0.0, 0.55]);
%plot2svg('mse_different_measures.svg', 3);


fpga和matlab
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
mspn人体姿态检测算法模型
08-16
CVPR 2019 | Rethinking on Multi-Stage Networks for Human Pose Estimation CVPR 2019 | MSPN 重新思考多阶段人体姿态估计网络模型资源 没有coco数据
msp6050陀螺仪
11-11
基于msp430单片机的mpu6050陀螺仪资料。。
排序算法
MSP_甄心cherish的专栏
05-20 419
冒泡 void BubbleSort(int[] num) { int n = num.Length; for (int i = 0; i < n-1; i++) { for (int j = 0; j < n - i - 1; j++) {
MSP估计算法的MATLAB仿真,含仿真操作录像
04-07
2.领域：MSP估计算法。 3.内容：MSP估计算法的MATLAB仿真,含仿真操作录像。 MSP_GD_vector_mean_bias_KL1(k) = mean(Rayleigh_MSP_results_GD_KL1(:,k)) - sigma_vector(k); MSP_GD_vector_mean_bias_KL2(k) = ...
MSP-estimate算法仿真-源码
10-01
**MSP Estimate 算法仿真** MSP Estimate（Minimum Spanning Projection）算法是一种在信号处理和数据分析领域中广泛使用的算法。它主要用于估计信号的基向量，特别是在高维数据降维时，如主成分分析(PCA)或独立...
MSP430控制6050
09-21
卡尔曼滤波是一种有效的在线估计算法，适用于处理带有随机噪声的动态系统。在平衡小车项目中，卡尔曼滤波可以融合来自MPU6050的加速度和角速度数据，提供更准确的倾斜角度估计。它通过预测和更新步骤，结合先验信息...
GAMMA MSP说明文档
10-21
例如，调整数据的格式和内容以符合算法要求。 在参数文件生成部分，文档提到了为特定SAR传感器生成相应的参数文件。不同传感器的参数可能会有所不同，需要根据传感器的具体类型来创建相应的参数文件。 ...
基于MSP430F5529的MPU6050姿态解算（移植DMP库）
08-08
总的来说，基于MSP430F5529和MPU6050的DMP姿态解算项目是一项综合了微控制器编程、传感器数据处理和运动估计算法的任务。通过深入理解和实践，我们可以构建一个高效、稳定且精确的六轴姿态测量系统。
算法大全及MATLAB代码实现
08-06
里面包含了很多很实用的算法,当然也有很多经典的算法,括用MATLAB实现的原代码,是不可多得的资源.
matlab算法大全
10-15
matlab实现的各类算法的文档，详细描述了各类智能算法的原理，当时30分下的
MATLAB算法源代码.zip
09-27
案例源代码关于MATLAB，分享从学习案例源代码关于MATLAB，分享从学习案例源代码关于MATLAB，分享从学习
fem Triangular Mesh有限元三角网格生成器
FPGA/MATLAB学习教程/源码/项目合作开发
01-14 1万+
%This example generates NE elements for a rectangular structure of %length = Ly units and width = Lx units with Nx divisions on the x %axis using femTriangularMeshGenerator function % Kehinde Orolu % Systems Engineering ...
毕业设计-基于 MATLAB 的图形图像处理系统的设计与实现
最新发布
Hai_Lang_IT的博客
01-14 7890
毕业设计-基于 MATLAB 的图形图像处理系统的设计与实现：在数字信息化的今天，我们都被各种各样的信息所包围着，如何这些海量的信息里面快 速准确的寻找出有用的信息，成为了你能脱颖而出的关键。而信息是抽象的，它依附在各种 媒体所表示的数据中，其中，图像信息是人类获取信息的重要来源之一。 数字图像处理技术是通过计算机对图像进行去除噪声、复原、增强、压缩、几何变换、 提取特征等处理的方法。20世纪初，图像处理首次应用到海底电缆传送图像的质量优化。随着科学技术的发展，计算机网络已是人们生活中无法离去的工具，故信
素数测试算法
MSP_甄心cherish的专栏
05-17 739
昨天刷LeetCode 时候遇到判断素数的问题 204.Count Primes ，想起hihocoder上之前也出现过，但是当时没看。 于是今天整理了一些关于判断一个数是否是素数的知识。因为大部分的内容都是别人的，所以下文主要是提供一些参考链接 以下假设要判断的数为n 1、传统判断方式 判断n是否能被2-n^(1/2)中的数整除，即 204. Count Primes 的解法1
都说FPGA高端，它到底能干啥？
03-04 1862
跟大家聊完了什么是 FPGA 之后，我想大家应该对自己手中那个“黑方块”有了一定的主观印象，至少明白了它和普通芯片的区别了，那么接下来，另一个问题就出现了，FPGA 我能用它做什么，我学会...
FPGA学习经验分享——入门篇
热门推荐
GLM798491781的博客
06-16 1万+
FPGA是一个高度集成化的芯片，其学习过程既需要编程，又需要弄懂硬件电路和计算机架构。涉及到的知识和基础非常多，如果不合理地安排学习内容，学习过程会非常漫长和枯燥。这篇文章主要阐述了对于入门FPGA的一些经验分享，希望能够给想学FPGA的人一些引导，少走一些弯路。入门学习FPGA主要分为以下三个阶段： 在正式开始学习FPGA之前，这里希望各位拿一本数电书好好看一下（相关专业的应该都学过数电这门专业课）无论有没有学过，需要把基本的逻辑运算的规则，与或非、同或异或等都搞明白，了解数字电路的原理和基本
语音增强
FPGA/MATLAB学习教程/源码/项目合作开发
09-28 7091
随着人们对语音增强知识的认识和发展，各种各样的语音增强算法都相应的发展起来。如前所述，由于噪声特性各异，总的来说，现在比较流行的算法主要有以下几种： 小波分解法； 听觉屏蔽法； 噪声对消法； 谐波增强法； 基于语音生成模型的增强算法； 基于短时谱估计的增强算法； 以上的各种语音增强算法虽然在具体实现上是有差别的，但从另一个方面来说，它们都不得不在语音的可懂度和主观度量这两个方向上做一番权衡。至于到底侧重与哪一方面，就要看算法内部的参数选取了。 其中，噪声对消法的基本原理是从带噪语...
基于站点休眠的中继网络动态节能拓扑控制
FPGA/MATLAB学习教程/源码/项目合作开发
09-09 3810
1.1 课题研究背景与研究意义 蜂窝网络不仅需要能够为用户提供高质量的语音服务，而且要能够提供大量的数据传输服务，这就决定了蜂窝网络的发展必须要进一步提高系统容量和高速数据速率覆盖，而传统的蜂窝网络基本无法满足目前的需求。为了满足不断提高系统需求，需要通过通过增加基站密度可以提升系统容量，提高数据传输速率，但是，这会大大增加网络的成本为代价来实现的。仅仅当通信用户数目也以和基站同样级别增加的时候才是可行的[01]。但这在大部分国家，特别是在一些发达国家，蜂窝电话己经高度普及，因此这种方案几乎无法被接受。另
基于 MSP430 和压电传感器的心率估计算法：最小均方误差与概率分析
问题的核心是通过一组观测值，其中信号`s`受到随机噪声`n`的影响，来估计信号`s`的均值。信号`s`是一个零均值的随机变量，其方差为`2sσ`，而观测到的信号包括了信号`s`和白噪声`n`的加总。 具体而言，给出了如下...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

fpga和matlab

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值