• 这段代码对内存很高，所使用图片尽量控制在200*300范围内 img_name='002.bmp'; % 原始图像 I=double(imread(img_name))/255; % 获取图像大小 [h,w,c]=size(I); win_size = 7; img_size=w*h; dehaze=zeros...
这段代码对内存很高，所使用图片尽量控制在200*300范围内

img_name='002.bmp';

% 原始图像

I=double(imread(img_name))/255;

% 获取图像大小

[h,w,c]=size(I);

win_size = 7;

img_size=w*h;

dehaze=zeros(img_size*c,1);

dehaze=reshape(dehaze,h,w,c);

figure, imshow(I);

win_dark=zeros(img_size ,1);

%这段代码可用矩阵处理

for cc=1:img_size

win_dark(cc)=1;

end

win_dark=reshape(win_dark,h,w);

%计算分块darkchannel，此处也尝试用矩阵处理，循环太多

for j=1+win_size:w-win_size

for i=win_size+1:h-win_size

m_pos_min = min(I(i,j,:));

for n=j-win_size:j+win_size

for m=i-win_size:i+win_size

if(win_dark(m,n)>m_pos_min)

win_dark(m,n)=m_pos_min;

end

end

end

end

end

figure, imshow(win_dark);

%输出darkchannel图像

%%%%%%%%%%%%%%%

for cc=1:img_size

win_dark(cc)=1-win_dark(cc);

end

%%%%%%%%%%%%%%%

%选定精确dark value坐标

win_b = zeros(img_size,1);

%rem函数为求余函数，有可能是进行边缘处理

for ci=1:h

for cj=1:w

if(rem(ci-8,15)<1)

if(rem(cj-8,15)<1)

win_b(ci*w+cj)=win_dark(ci*w+cj);

end

end

end

end

%显示分块darkchannel

%figure, imshow(win_dark);

neb_size = 9;

win_size = 1;

epsilon = 0.0000001;

%指定矩阵形状

indsM=reshape([1:img_size],h,w);

%是不是win_dark

%计算矩阵L

tlen = img_size*neb_size^2;

row_inds=zeros(tlen ,1);

col_inds=zeros(tlen,1);

vals=zeros(tlen,1);

len=0;

for j=1+win_size:w-win_size

for i=win_size+1:h-win_size

if(rem(ci-8,15)<1)

if(rem(cj-8,15)<1)

continue;

end

end

win_inds=indsM(i-win_size:i+win_size,j-win_size:j+win_size);

win_inds=win_inds(:);%列显示

winI=I(i-win_size:i+win_size,j-win_size:j+win_size,:);

winI=reshape(winI,neb_size,c); %三个通道被拉平成为一个二维矩阵 3*9

win_mu=mean(winI,1)';  %求每一列的均值 如果第二个参数为2 则为求每一行的均值  //矩阵变向量

win_var=inv(winI'*winI/neb_size-win_mu*win_mu' +epsilon/neb_size*eye(c)); %求方差

winI=winI-repmat(win_mu',neb_size,1);%求离差

tvals=(1+winI*win_var*winI')/neb_size;% 求论文所指的矩阵L

row_inds(1+len:neb_size^2+len)=reshape(repmat(win_inds,1,neb_size),...

neb_size^2,1);

col_inds(1+len:neb_size^2+len)=reshape(repmat(win_inds',neb_size,1),...

neb_size^2,1);

vals(1+len:neb_size^2+len)=tvals(:);

len=len+neb_size^2;

end

end

vals=vals(1:len);

row_inds=row_inds(1:len);

col_inds=col_inds(1:len);

%创建稀疏矩阵

A=sparse(row_inds,col_inds,vals,img_size,img_size);

%求行的总和 sumA为列向量

sumA=sum(A,2);

%spdiags(sumA(:),0,img_size,img_size) 创建img_size大小的稀疏矩阵其元素是sumA中的列元素放在由0指定的对角线位置上。

A=spdiags(sumA(:),0,img_size,img_size)-A;

%创建稀疏矩阵

D=spdiags(win_b(:),0,img_size,img_size);

lambda=1;

x=(A+lambda*D)\(lambda*win_b(:).*win_b(:));   %求解式15

%去掉0-1范围以外的数

alpha=max(min(reshape(x,h,w),1),0);

figure, imshow(alpha);

A=220/255; %大气光没有去计算

%去雾

for i=1:c

for j=1:h

for l=1:w

dehaze(j,l,i)=(I(j,l,i)-A)/alpha(j,l)+A;

end

end

end

figure, imshow(dehaze);
展开全文
• 这是一个学习机器人避障算法的matlab仿真代码，直接下载运行就可以使用，备注非常详细，大家可以自定义避障地图，也可以更改参数实现不同的避障
• 程序中备注了 每一步的注释。觉得好可以好评！用直接法（fft）和自带函数(AR)估计功率谱 与 自己写的AR过程推导估计做了对比 结果一致，代码正确。
• 国外学者的开源卡尔曼滤波MATLAB代码备注详细，可以用于目标跟踪基础学习
• 学习启发式算法时，旅行商问题是一个经典的例子。其中，遗传算法可以用来求解该问题。遗传算法是一种进化算法，由于其启发式算法的属性，并不能保证得到最优解。求解效果与初始种群选取，编码...（备注：对于一般的 ...
学习启发式算法时，旅行商问题是一个经典的例子。其中，遗传算法可以用来求解该问题。遗传算法是一种进化算法，由于其启发式算法的属性，并不能保证得到最优解。求解效果与初始种群选取，编码方法，选择方法，交叉变异规则有关。

上课时，老师不知从哪里找了一个非常粗糙的程序，自己将不少错误修正，增加了一些注释方便理解，并增加了一些代码使程序更完美。该代码可以动态显示每一代的路线，非常直观！ （备注：对于一般的 TSP 问题，发现通过将其构造成整数规划问题，利用数学规划求解软件 Gurobi 中的 Callback 方法求解，即使大规模问题 （75 个城市）也可以在 1 秒钟内得到最优解。就没必要用启发式算法了。参看网址：https://www.gurobi.com/resource/traveling-salesman-problem/ ）

本程序的显示效果：

代码：

function GaTSPChen

% mainly amended by Chen Zhen, 2012~2016

CityNum = 30; % 城市数目，可以选 10, 30, 50, 75
[dislist, Clist] = tsp(CityNum); % dislist 为城市之间相互的距离，Clist 为各城市的坐标

inn = 30; % 初始种群大小
gnMax = 500;  % 最大代数
crossProb = 0.8; % 交叉概率
muteProb = 0.8; % 变异概率

% 随机产生初始种群
population = zeros(inn, CityNum); % population 为初始种群，包括多条染色体
for i = 1 : inn
population(i,:) = randperm(CityNum);
end
[~, cumulativeProbs] = calPopulationValue(population, dislist); % 计算种群每条染色体的累计概率

generationNum = 1;
generationMeanValue = zeros(generationNum, 1); % 每一代的平均距离
generationMaxValue = zeros(generationNum, 1);  % 每一代的最短距离
bestRoute = zeros(inn, CityNum); % 最佳路径
newPopulation = zeros(inn, CityNum); % 新的种群
while generationNum < gnMax + 1
for j = 1 : 2 : inn
selectedChromos = select(cumulativeProbs);  % 选择操作，选出两条需要交叉编译的染色体，即父亲母亲
crossedChromos = cross(population, selectedChromos, crossProb);  % 交叉操作，返回交叉后的染色体
newPopulation(j, :) = mut(crossedChromos(1, :),muteProb);  % 对交叉后的染色体进行变异操作
newPopulation(j + 1, :) = mut(crossedChromos(2, :), muteProb); % 对交叉后的染色体进行变异操作
end
population = newPopulation;  %产生了新的种群
[populationValue, cumulativeProbs] = calPopulationValue(population, dislist);  % 计算新种群的适应度
% 记录当前代最好和平均的适应度
[fmax, nmax] = max(populationValue); % 因为计算适应度时取距离的倒数，这里面取最大的倒数，即最短的距离
generationMeanValue(generationNum) = 1 / mean(populationValue);
generationMaxValue(generationNum) = 1 / fmax;
bestChromo = population(nmax, :);  % 前代最佳染色体，即对应的路径
bestRoute(generationNum, :) = bestChromo; % 记录每一代的最佳染色体
drawTSP(Clist, bestChromo, generationMaxValue(generationNum), generationNum, 0);
generationNum = generationNum + 1;
end
[bestValue,index] = min(generationMaxValue);
drawTSP(Clist, bestRoute(index, :), bestValue, index,1);

figure(2);
plot(generationMaxValue, 'r');
hold on;
plot(generationMeanValue, 'b');
grid;
title('搜索过程');
legend('最优解', '平均解');
fprintf('遗传算法得到的最短距离: %.2f\n', bestValue);
fprintf('遗传算法得到的最短路线');
disp(bestRoute(index, :));
end

%------------------------------------------------
% 计算所有染色体的适应度
function [chromoValues, cumulativeProbs] = calPopulationValue(s, dislist)
inn = size(s, 1);  % 读取种群大小
chromoValues = zeros(inn, 1);
for i = 1 : inn
chromoValues(i) = CalDist(dislist, s(i, :));  % 计算每条染色体的适应度
end
chromoValues = 1./chromoValues'; % 因为让距离越小，选取的概率越高，所以取距离倒数

% 根据个体的适应度计算其被选择的概率
fsum = 0;
for i = 1 : inn
% 乘以15次方的原因是让好的个体被选取的概率更大（因为适应度取距离的倒数，若不乘次方，则个体相互之间的适应度差别不大），换成一个较大的数也行
fsum = fsum + chromoValues(i)^15;
end

% 计算单个概率
probs = zeros(inn, 1);
for i = 1: inn
probs(i) = chromoValues(i)^15 / fsum;
end

% 计算累积概率
cumulativeProbs = zeros(inn,1);
cumulativeProbs(1) = probs(1);
for i = 2 : inn
cumulativeProbs(i) = cumulativeProbs(i - 1) + probs(i);
end
cumulativeProbs = cumulativeProbs';
end

%--------------------------------------------------
%“选择”操作，返回所选择染色体在种群中对应的位置
% cumulatedPro 所有染色体的累计概率
function selectedChromoNums = select(cumulatedPro)
selectedChromoNums = zeros(2, 1);
% 从种群中选择两个个体，最好不要两次选择同一个个体
for i = 1 : 2
r = rand;  % 产生一个随机数
prand = cumulatedPro - r;
j = 1;
while prand(j) < 0
j = j + 1;
end
selectedChromoNums(i) = j; % 选中个体的序号
if i == 2 && j == selectedChromoNums(i - 1)    % 若相同就再选一次
r = rand;  % 产生一个随机数
prand = cumulatedPro - r;
j = 1;
while prand(j) < 0
j = j + 1;
end
end
end
end

%------------------------------------------------
% “交叉”操作
function crossedChromos = cross(population, selectedChromoNums, crossProb)
length = size(population, 2); % 染色体的长度
crossProbc = crossMuteOrNot(crossProb);  %根据交叉概率决定是否进行交叉操作，1则是，0则否
crossedChromos(1,:) = population(selectedChromoNums(1), :);
crossedChromos(2,:) = population(selectedChromoNums(2), :);
if crossProbc == 1
c1 = round(rand * (length - 2)) + 1;  %在[1,bn - 1]范围内随机产生一个交叉位 c1
c2 = round(rand * (length - 2)) + 1;  %在[1,bn - 1]范围内随机产生一个交叉位 c2
chb1 = min(c1, c2);
chb2 = max(c1,c2);
middle = crossedChromos(1,chb1+1:chb2); % 两条染色体 chb1 到 chb2 之间互换位置
crossedChromos(1,chb1 + 1 : chb2)= crossedChromos(2, chb1 + 1 : chb2);
crossedChromos(2,chb1 + 1 : chb2)= middle;
for i = 1 : chb1 % 看交叉后，染色体上是否有相同编码的情况（路径上重复出现两个城市）。若有，则该编码不参与交叉
while find(crossedChromos(1,chb1 + 1: chb2) == crossedChromos(1, i))
location = find(crossedChromos(1,chb1 + 1: chb2) == crossedChromos(1, i));
y = crossedChromos(2,chb1 + location);
crossedChromos(1, i) = y;
end
while find(crossedChromos(2,chb1 + 1 : chb2) == crossedChromos(2, i))
location = find(crossedChromos(2, chb1 + 1 : chb2) == crossedChromos(2, i));
y = crossedChromos(1, chb1 + location);
crossedChromos(2, i) = y;
end
end
for i = chb2 + 1 : length
while find(crossedChromos(1, 1 : chb2) == crossedChromos(1, i))
location = logical(crossedChromos(1, 1 : chb2) == crossedChromos(1, i));
y = crossedChromos(2, location);
crossedChromos(1, i) = y;
end
while find(crossedChromos(2, 1 : chb2) == crossedChromos(2, i))
location = logical(crossedChromos(2, 1 : chb2) == crossedChromos(2, i));
y = crossedChromos(1, location);
crossedChromos(2, i) = y;
end
end
end
end

%--------------------------------------------------
%“变异”操作
% choromo 为一条染色体
function snnew = mut(chromo,muteProb)
length = size(chromo, 2); % 染色体的的长度
snnew = chromo;
muteProbm = crossMuteOrNot(muteProb);  % 根据变异概率决定是否进行变异操作，1则是，0则否
if muteProbm == 1
c1 = round(rand*(length - 2)) + 1;  % 在 [1, bn - 1]范围内随机产生一个变异位
c2 = round(rand*(length - 2)) + 1;  % 在 [1, bn - 1]范围内随机产生一个变异位
chb1 = min(c1, c2);
chb2 = max(c1, c2);
x = chromo(chb1 + 1 : chb2);
snnew(chb1 + 1 : chb2) = fliplr(x); % 变异，则将两个变异位置的染色体倒转
end
end

% 根据变异或交叉概率，返回一个 0 或 1 的数
function crossProbc = crossMuteOrNot(crossMuteProb)
test(1: 100) = 0;
l = round(100 * crossMuteProb);
test(1 : l) = 1;
n = round(rand * 99) + 1;
crossProbc = test(n);
end

%------------------------------------------------
% 计算一条染色体的适应度
% dislist 为所有城市相互之间的距离矩阵
% chromo 为一条染色体，即一条路径
function chromoValue = CalDist(dislist, chromo)
DistanV = 0;
n = size(chromo, 2); % 染色体的长度
for i = 1 : (n - 1)
DistanV = DistanV + dislist(chromo(i), chromo(i + 1));
end
DistanV = DistanV + dislist(chromo(n), chromo(1));
chromoValue = DistanV;
end

%------------------------------------------------
% 画图
% Clist 为城市坐标
% route 为一条路径
function drawTSP(Clist, route, generationValue, generationNum,isBestGeneration)
CityNum = size(Clist, 1);
for i = 1 : CityNum - 1
plot([Clist(route(i), 1),Clist(route(i + 1), 1)], [Clist(route(i),2),Clist(route(i+1),2)],'ms-','LineWidth',2,'MarkerEdgeColor','k','MarkerFaceColor','g');
text(Clist(route(i), 1),Clist(route(i), 2), ['  ', int2str(route(i))]);
text(Clist(route(i+1), 1),Clist(route(i + 1), 2), ['  ', int2str(route(i+1))]);
hold on;
end
plot([Clist(route(CityNum), 1), Clist(route(1), 1)], [Clist(route(CityNum), 2), Clist(route(1), 2)],'ms-','LineWidth',2,'MarkerEdgeColor','k','MarkerFaceColor','g');
title([num2str(CityNum),'城市TSP']);
if isBestGeneration == 0 && CityNum ~= 10
text(5, 5, ['第 ',int2str(generationNum),' 代','  最短距离为 ', num2str(generationValue)]);
else
text(5, 5, ['最终搜索结果：最短距离 ',num2str(generationValue),'， 在第 ',num2str(generationNum),' 代达到']);
end
if CityNum == 10  % 因为文字显示位置不一样，所以将城市数目为 10 时单独编写
if isBestGeneration == 0
text(0, 0, ['第 ',int2str(generationNum),' 代','  最短距离为 ', num2str(generationValue)]);
else
text(0, 0, ['最终搜索结果：最短距离 ',num2str(generationValue),'， 在第 ', num2str(generationNum),' 代达到']);
end
end
hold off;
pause(0.005);
end

%------------------------------------------------
%城市位置坐标
function [DLn, cityn] = tsp(n)
DLn = zeros(n, n);
if n == 10
city10 = [0.4 0.4439;0.2439 0.1463;0.1707 0.2293;0.2293 0.761;0.5171 0.9414;
0.8732 0.6536;0.6878 0.5219;0.8488 0.3609;0.6683 0.2536;0.6195 0.2634];%10 cities d'=2.691
for i = 1 : 10
for j = 1 : 10
DLn(i, j) = ((city10(i,1)-city10(j,1))^2 + (city10(i,2)-city10(j,2))^2)^0.5;
end
end
cityn = city10;
end
if n == 30
city30 = [41 94;37 84;54 67;25 62;7 64;2 99;68 58;71 44;54 62;83 69;64 60;18 54;22 60;
83 46;91 38;25 38;24 42;58 69;71 71;74 78;87 76;18 40;13 40;82 7;62 32;58 35;45 21;41 26;44 35;4 50]; % 30 cities d' = 423.741 by D B Fogel
for i = 1 : 30
for j = 1 : 30
DLn(i,j) = ((city30(i,1)-city30(j,1))^2+(city30(i,2)-city30(j,2))^2)^0.5;
end
end
cityn = city30;
end

if n == 50
city50 = [31 32;32 39;40 30;37 69;27 68;37 52;38 46;31 62;30 48;21 47;25 55;16 57;
17 63;42 41;17 33;25 32;5 64;8 52;12 42;7 38;5 25; 10 77;45 35;42 57;32 22;
27 23;56 37;52 41;49 49;58 48;57 58;39 10;46 10;59 15;51 21;48 28;52 33;
58 27;61 33;62 63;20 26;5 6;13 13;21 10;30 15;36 16;62 42;63 69;52 64;43 67];%50 cities d'=427.855 by D B Fogel
for i = 1 : 50
for j = 1:50
DLn(i, j) = ((city50(i,1) - city50(j,1))^2 + (city50(i,2) - city50(j,2))^2)^0.5;
end
end
cityn = city50;
end

if n == 75
city75 = [48 21;52 26;55 50;50 50;41 46;51 42;55 45;38 33;33 34;45 35;40 37;50 30;
55 34;54 38;26 13;15 5;21 48;29 39;33 44;15 19;16 19;12 17;50 40;22 53;21 36;
20 30;26 29;40 20;36 26;62 48;67 41;62 35;65 27;62 24;55 20;35 51;30 50;
45 42;21 45;36 6;6 25;11 28;26 59;30 60;22 22;27 24;30 20;35 16;54 10;50 15;
44 13;35 60;40 60;40 66;31 76;47 66;50 70;57 72;55 65;2 38;7 43;9 56;15 56;
10 70;17 64;55 57;62 57;70 64;64 4;59 5;50 4;60 15;66 14;66 8;43 26]; % 75 cities d'=549.18 by D B Fogel
for i = 1 : 75
for j = 1 : 75
DLn(i,j) = ((city75(i,1)-city75(j,1))^2 + (city75(i,2)-city75(j,2))^2)^0.5;
end
end
cityn = city75;
end
end



展开全文
• 滤波器 matlab 设计仿真 代码备注
• Fisher线性判别实验，.m文件，各行代码功能备注明确，有利于学习，matlab直接运行，数据更改即可用于其他类别实验分析。
• 老外写的一个程序，双输入单输出，并不是simulink模块，代码有点长，但是备注很详细，看懂问题不大。
• MATLAB 使用少量样本的K-SVD过完备字典学习代码（中文备注） 最近在学习稀疏表示与压缩感知理论，在使用K-SVD方面我遇到了一个问题，就是手上样本数量很少，但是需要构建过完备字典，我看到好像很多人也有这个问题。...
MATLAB 使用少量样本的K-SVD过完备字典学习代码（中文备注）
最近在学习稀疏表示与压缩感知理论，在使用K-SVD方面我遇到了一个问题，就是手上样本数量很少，但是需要构建过完备字典，我看到好像很多人也有这个问题。
目前在论坛里看到流传的K-SVD的MATLAB代码主要是下面这两个，都需要超过样本长度的样本数才能训练过完备字典：
dictionary learning tools中的K-SVD算法代码（转自K-SVD算法）
function [Dictionary,output] = KSVD(...
Data,... % an nXN matrix that contins N signals (Y), each of dimension n.
param)
% =========================================================================
%                          K-SVD algorithm
% =========================================================================
% The K-SVD algorithm finds a dictionary for linear representation of
% signals. Given a set of signals, it searches for the best dictionary that
% can sparsely represent each signal. Detailed discussion on the algorithm
% and possible applications can be found in "The K-SVD: An Algorithm for
% Designing of Overcomplete Dictionaries for Sparse Representation", written
% by M. Aharon, M. Elad, and A.M. Bruckstein and appeared in the IEEE Trans.
% On Signal Processing, Vol. 54, no. 11, pp. 4311-4322, November 2006.
% =========================================================================
% INPUT ARGUMENTS:
% Data                         an nXN matrix that contins N signals (Y), each of dimension n.
% param                        structure that includes all required
%                                 parameters for the K-SVD execution.
%                                 Required fields are:
%    K, ...                    the number of dictionary elements to train
%    numIteration,...          number of iterations to perform.
%    errorFlag...              if =0, a fix number of coefficients is
%                                 used for representation of each signal. If so, param.L must be
%                                 specified as the number of representing atom. if =1, arbitrary number
%                                 of atoms represent each signal, until a specific representation error
%                                 is reached. If so, param.errorGoal must be specified as the allowed
%                                 error.
%    preserveDCAtom...         if =1 then the first atom in the dictionary
%                                 is set to be constant, and does not ever change. This
%                                 might be useful for working with natural
%                                 images (in this case, only param.K-1
%                                 atoms are trained).
%    (optional, see errorFlag) L,...                 % maximum coefficients to use in OMP coefficient calculations.
%    (optional, see errorFlag) errorGoal, ...        % allowed representation error in representing each signal.
%    InitializationMethod,...  mehtod to initialize the dictionary, can
%                                 be one of the following arguments:
%                                 * 'DataElements' (initialization by the signals themselves), or:
%                                 * 'GivenMatrix' (initialization by a given matrix param.initialDictionary).
%    (optional, see InitializationMethod) initialDictionary,...      % if the initialization method
%                                 is 'GivenMatrix', this is the matrix that will be used.
%    (optional) TrueDictionary, ...        % if specified, in each
%                                 iteration the difference between this dictionary and the trained one
%                                 is measured and displayed.
%    displayProgress, ...      if =1 progress information is displyed. If param.errorFlag==0,
%                                 the average repersentation error (RMSE) is displayed, while if
%                                 param.errorFlag==1, the average number of required coefficients for
%                                 representation of each signal is displayed.
% =========================================================================
% OUTPUT ARGUMENTS:
%  Dictionary                  The extracted dictionary of size nX(param.K).
%  output                      Struct that contains information about the current run. It may include the following fields:
%    CoefMatrix                  The final coefficients matrix (it should hold that Data equals approximately Dictionary*output.CoefMatrix.
%    ratio                       If the true dictionary was defined (in
%                                synthetic experiments), this parameter holds a vector of length
%                                param.numIteration that includes the detection ratios in each
%                                iteration).
%    totalerr                    The total representation error after each
%                                iteration (defined only if
%                                param.displayProgress=1 and
%                                param.errorFlag = 0)
%    numCoef                     A vector of length param.numIteration that
%                                include the average number of coefficients required for representation
%                                of each signal (in each iteration) (defined only if
%                                param.displayProgress=1 and
%                                param.errorFlag = 1)
% =========================================================================

%%********************* Dimension reduction ****************************
for i = 1:1:250
for j = 1:1:250
Data(i,j) = Data(i,j,1);
end
end

if (~isfield(param,'displayProgress'))
param.displayProgress = 0;
end
totalerr(1) = 99999;
if (isfield(param,'errorFlag')==0)
param.errorFlag = 0;
end

if (isfield(param,'TrueDictionary'))
displayErrorWithTrueDictionary = 1;
ErrorBetweenDictionaries = zeros(param.numIteration+1,1); %产生零矩阵
ratio = zeros(param.numIteration+1,1);
else
displayErrorWithTrueDictionary = 0;
ratio = 0;
end
if (param.preserveDCAtom>0)
FixedDictionaryElement(1:size(Data,1),1) = 1/sqrt(size(Data,1));
else
FixedDictionaryElement = [];
end
% coefficient calculation method is OMP with fixed number of coefficients

if (size(Data,2) < param.K)
disp('Size of data is smaller than the dictionary size. Trivial solution...');
Dictionary = Data(:,1:size(Data,2));
return;
elseif (strcmp(param.InitializationMethod,'DataElements'))
Dictionary(:,1:param.K-param.preserveDCAtom) = Data(:,1:param.K-param.preserveDCAtom);
elseif (strcmp(param.InitializationMethod,'GivenMatrix'))
Dictionary(:,1:param.K-param.preserveDCAtom) = param.initialDictionary(:,1:param.K-param.preserveDCAtom);
end
% reduce the components in Dictionary that are spanned by the fixed
% elements
if (param.preserveDCAtom)
tmpMat = FixedDictionaryElement \ Dictionary;
Dictionary = Dictionary - FixedDictionaryElement*tmpMat;
end
%normalize the dictionary.
Dictionary = Dictionary*diag(1./sqrt(sum(Dictionary.*Dictionary)));
Dictionary = Dictionary.*repmat(sign(Dictionary(1,:)),size(Dictionary,1),1); % multiply in the sign of the first element.
totalErr = zeros(1,param.numIteration);

% the K-SVD algorithm starts here.

for iterNum = 1:param.numIteration
% find the coefficients
if (param.errorFlag==0)
% CoefMatrix = mexOMPIterative2(Data, [FixedDictionaryElement,Dictionary],param.L);
CoefMatrix = OMP([FixedDictionaryElement,Dictionary],Data, param.L);
else
%CoefMatrix = mexOMPerrIterative(Data, [FixedDictionaryElement,Dictionary],param.errorGoal);
CoefMatrix = OMPerr([FixedDictionaryElement,Dictionary],Data, param.errorGoal);
param.L = 1;
end

replacedVectorCounter = 0;
rPerm = randperm(size(Dictionary,2));
for j = rPerm
[betterDictionaryElement,CoefMatrix,addedNewVector] = I_findBetterDictionaryElement(Data,...
[FixedDictionaryElement,Dictionary],j+size(FixedDictionaryElement,2),...
CoefMatrix ,param.L);
Dictionary(:,j) = betterDictionaryElement;
if (param.preserveDCAtom)
tmpCoef = FixedDictionaryElement\betterDictionaryElement;
Dictionary(:,j) = betterDictionaryElement - FixedDictionaryElement*tmpCoef;
Dictionary(:,j) = Dictionary(:,j)./sqrt(Dictionary(:,j)'*Dictionary(:,j));
end
replacedVectorCounter = replacedVectorCounter+addedNewVector;
end
if (iterNum>1 & param.displayProgress)
if (param.errorFlag==0)
output.totalerr(iterNum-1) = sqrt(sum(sum((Data-[FixedDictionaryElement,Dictionary]*CoefMatrix).^2))/prod(size(Data)));
disp(['Iteration   ',num2str(iterNum),'   Total error is: ',num2str(output.totalerr(iterNum-1))]);
else
output.numCoef(iterNum-1) = length(find(CoefMatrix))/size(Data,2);
disp(['Iteration   ',num2str(iterNum),'   Average number of coefficients: ',num2str(output.numCoef(iterNum-1))]);
end
end
if (displayErrorWithTrueDictionary )
[ratio(iterNum+1),ErrorBetweenDictionaries(iterNum+1)] = I_findDistanseBetweenDictionaries(param.TrueDictionary,Dictionary);
disp(strcat(['Iteration  ', num2str(iterNum),' ratio of restored elements: ',num2str(ratio(iterNum+1))]));
output.ratio = ratio;
end
Dictionary = I_clearDictionary(Dictionary,CoefMatrix(size(FixedDictionaryElement,2)+1:end,:),Data);

if (isfield(param,'waitBarHandle'))
waitbar(iterNum/param.counterForWaitBar);
end
end
output.CoefMatrix = CoefMatrix;
Dictionary = [FixedDictionaryElement,Dictionary];


还有一个简化的版本
（转自用于训练系数字典的K_SVD算法）
function [A,x]= K_SVD(y,codebook_size,errGoal)
%==============================
%input parameter
%   y - input signal
%   codebook_size - count of atoms
%output parameter
%   A - dictionary
%   x - coefficent
%reference:K-SVD:An Algorithm for Designing of Overcomplete Dictionaries
%          for Sparse Representation,Aharon M.,Elad M.etc
%==============================
if(size(y,2)<codebook_size)
disp('codebook_size is too large or training samples is too small');
return;
end
% initialization
[rows,cols]=size(y);
r=randperm(cols);
A=y(:,r(1:codebook_size));
A=A./repmat(sqrt(sum(A.^2,1)),rows,1);
ksvd_iter=10;
for k=1:ksvd_iter
% sparse coding
if nargin==2
x=OMP(A,y,5.0/6*rows);
elseif nargin==3
x=OMPerr(A,y,errGoal);
end
% update dictionary
for m=1:codebook_size
mindex=find(x(m,:));
if ~isempty(mindex)
mx=x(:,mindex);
mx(m,:)=0;
my=A*mx;
resy=y(:,mindex);
mE=resy-my;
[u,s,v]=svds(mE,1);
A(:,m)=u;
x(m,mindex)=s*v';
end
end
end

这两个代码初始字典都是从样本中获得的，代码中都对样本长度和字典原子数关系有限制，字典原子数不能超过样本长度，换句话说，要构建过完备字典，就必须有超过样本长度的样本数。
但是很多人都有需要在仅有少量样本（样本数量小于样本长度）的情况下训练过完备字典，事实上，只需要改变初始字典的构建方式就可以了，初始字典可以构建一个指定大小的随机数矩阵，再进行L2范数归一化。
当然构建随机数字典是最普适的一种方式，但是要获得较好的效果也需要相对较高的迭代次数，各位也可以根据自己需求更改初始化字典，如DCT、FFT、小波等形式，初始字典构筑方式有许多，可以构建单个过完备字典，也可以通过几个字典拼接而成，K-SVD算法结果和初始字典的相关性很高，可以根据自己的目的选择合适的初始化字典，以下是我根据第二个代码改造的使用随机初始矩阵的代码，顺带进行了中文备注方便大家学习使用~
使用随机初始字典的K-SVD代码：
function [ D , x ] = myksvd( y , K , iter , L )
%------------------K-SVD过完备字典学习------------------
%    输入参数
%    y----------训练样本集（MxN维 M为一个样本长度，N为样本数）
%    K----------字典原子（列）数
%    iter-------迭代次数
%    L----------目标稀疏度
%-------------------------------
%    输出参数
%    D----------稀疏字典
%    x----------样本的稀疏系数
%------------------------------------------------------
[M,~]=size(y);
%========================初始化字典=========================
d=rand(M,K);        %随机数初始字典

for i=1:K           %L2范数归一化
D(:,i)=d(:,i)./norm(d(:,i));
end
%==========================迭代============================
ff=waitbar(0,'K-SVD Dictionary Learning...');

for J=1:iter

%-----------稀疏编码----------
x=OMP(D,y,L);
%     x=CS_OMP(y,D,L);
%--------------------------------------------------

%-----------字典更新---------
fff=waitbar(0,'第k列字典更新中...');
for k=1:K
wk=find(x(k,:));
if ~isempty(wk)
%-----计算残差-----

mx=x(:,wk);    %消除x的k行零项对应列
mx(k,:)=0;     %让x的k行清零，因此残差项不包含dkxk
my=D*mx;       %为舍去零列及k行的乘积
resy=y(:,wk);  %舍去非零列的k
Ek=resy-my;    %直接得到Ek'

%-----SVD求解优化变量-----
[U,S,V]=svds(Ek,1);
D(:,k)=U;      %k列字典更新为左奇异矩阵第一个列向量
x(k,wk)=S*V';  %k行x更新为右奇异矩阵第一个行向量与第一个奇异值乘积
end
str=[['第',num2str(k),'列字典更新中...'],num2str(k/K*100),'%'];
waitbar(k/K,fff,str);
end
%-------------------------------------------------
close(fff);
str=[['K-SVD Dictionary Learning...   ',num2str(J),' / ',num2str(iter),'         '],num2str(J/iter*100),'%'];
waitbar(J/iter,ff,str);
end

close(ff);

K-SVD中使用的OMP代码
function A=OMP(D,X,L)
% 输入参数:
% D - 过完备字典，注意：必须字典的各列必须经过了规范化
% X - 信号
% L - 系数中非零元个数的最大值（可选，默认为D的列数，速度可能慢）
% 输出参数:
% A - 稀疏系数
P=size(X,2);
K=size(D,2);
ffff=waitbar(0,'OMP Running...');
for k=1:1:P
a=[];
x=X(:,k);
residual=x;
indx=zeros(L,1);
for j=1:1:L
proj=D'*residual;
[maxVal,pos]=max(abs(proj));
pos=pos(1);
indx(j)=pos;
a=pinv(D(:,indx(1:j)))*x;
residual=x-D(:,indx(1:j))*a;
if sum(residual.^2) < 1e-6
break;
end
end
temp=zeros(K,1);
temp(indx(1:j))=a;
A(:,k)=sparse(temp);
str=['OMP Running...   ',num2str(k/P*100),'%'];
waitbar(k/P,ffff,str);
end
close(ffff);
return;



展开全文
• 本资源包括，基于SEIR模型的新冠肺炎疫情分析matlab代码和最新的国内疫情数据集。代码已详细备注，具体模型详解见本人博客，大家可以下载交流，略有瑕疵，欢迎指正。
• 包含了bmp格式图像的空间矩求解算法。其中列出了七个不变量。代码可运行。代码参照数字图像处理第三版公式编写的。代码里面有备注
• 机械设计，V带电算MATLAB代码，含备注，使用GUI界面打开，内有注意事项与操作说明
• MatLab是一个快速开发程序的集成环境，意味着它关注于开发的舒适性，便捷性，而不是像C，Fortran语言...备注：这并不是matlab初学者教程，而是关于提高matlab代码运行性能的教程。一般而言，本文阐述的方法都能加速matl
MatLab是一个快速开发程序的集成环境，意味着它关注于开发的舒适性，便捷性，而不是像C，Fortran语言关注于计算性能。于是MatLab具有了灵活的语法，并能交互调试。

虽然MatLab并不能像C一样快，但是也许有一些方法，能够让它缩小与C语言的差距。

备注：这并不是matlab初学者教程，而是关于提高matlab代码运行性能的教程。一般而言，本文阐述的方法都能加速matlab代码的运行效率。但是，并没有声明到底哪一种方法是最快的。具体问题具体分析。use at your own risk。

在我们开始之前，让我们先回顾一下，我们学习本文的目的。我们是要抛开语言的区别，寻求运行效率最高的代码吗？
如果是这样，我建议你用C语言开发。其实，我们是想在得到最终结果之前，减少我们的开发，调试，运行时间。
本节阐述几个小技巧让开发更加简单。
1. 代码提示信息
在最近的matlab版本中，代码集成编辑器可以自动反馈可能出现的错误和优化建议。这些提示对学习matlab和优化代码很有帮助。

for k = 1:NumTrials
r = rand;
x(k) = runsim(r);
end可能，编辑器在runsim下有红色波浪线。这时将鼠标停在波浪线上，matlab会自动显示对这段代码的反馈信息。

或者选择Tools    ->    M-Lint    ->    Show M-Lint Report查看全部提示。

2. 代码组织结构

2.1 每个工程使用独立文件夹

这样能够保持相关文件都在一起，简化备份复制工程文件。

2.2 每个文件开头写清注释，特别是注释的第一行

文件开头注释的第一行又叫H1comment。它的作用是当你输入help(cd)时，会得到所有工程文件的列表和它们的H1comments。

2.3 将常用的命令行输入的代码写成脚本

如果发现重复输入一些命令，不如把这些代码写成脚本文件，节约时间并防止自己打错命令。
3. 避免丢失数据
3.1 不要在脚本中使用clear all命令
这是一个能让你触霉头的命令。任何在基本工作空间中存在的重要的变量都会不可挽回地消失。
3.2 小心多个操作对同一变量的修改

此时，result便把与input1有关的结果丢弃了。
3.3 小心能使matlab崩溃的东西

虽然matlab本身很可靠，但是一些第三方的mex函数或是过度的内存操作能够使matlab崩溃。
尤其是处理视频以及大规模的矩阵的时候。

在拥有良好的代码书写规范的前提下，我们开始讨论如何写高质量的matlab代码。


展开全文
• 这是一个学习机器人避障算法的matlab仿真代码，使用VFH+算法进行避障，直接下载运行就可以使用，备注非常详细，大家可以自定义避障地图，也可以更改参数实现不同的避障
• 这是一个学习机器人避障算法的matlab仿真代码，使用VFH+算法进行避障，直接下载运行就可以使用，备注非常详细，大家可以自定义避障地图，也可以更改参数实现不同的避障
• ACO-TSP蚁群matlab代码，用matlab打开可以直接用，计算智能的作业，代码很详细，有备注 蚁群算法（Ant Colony Optimization, ACO），又称蚂蚁算法，是一种用来在图中寻找优化路径的机率型算法。它由Marco Dorigo...
• 将一副图像用网格标记出来，并且改变原图像网格点像素，重要代码都是由备注的。为了不允许动态调整分数，而重新发布
• 该函数用于语音信号特征提取，详细用法以及参数设置都有说明，仅供学习参考。函数作者为 Kamil Wojcicki ，使用时必须保持作者备注的信息。
• 备注比较详细的GM-PHD滤波，值得大家借鉴学习，是国外学者的开源代码
• SPIHT算法源代码 MATLAB版本，已经备注好了，可以直接运行使用，特别适合新手
• 代码本人亲测调通，附代码备注。反演地表质量变化，陆地水储量变化必读代码。内附04年到10年全球的GRACE数据，海岸线数据。
• 弹性光网络中的KSP-FF-RSA算法matlab代码，实测有效，考虑了K最短路径、首次命中以及调制格式选择，最终能输出网络阻塞率，并提供多个候选网络拓扑测试，备注超级详细。
• 代码有详细的备注，可以帮助入门者快速熟悉遗传算法。也为需要优化遗传算法的人提供了遗传算法的框架，只需要简单修改就能完成
• 徐大大亲自测试完成的 跳频 代码备注非常详细 适合所有用户上手。。里面详细写了跳频m序列生成 高频载波生成 各类滤波 跳频点等，欢迎大家下载
•  代码可以复制%之间的内容（包括%）%到MATLAB里执行 一、matlab基本命令的使用 %% I. 清空环境变量及命令 clear all % 清除Workspace中的所有变量 clc % 清除Command Window中的所有命令 %% II. 变量...
• 来源| 中国公路学报知圈 | 进“汽车软件社群”，请加微信13636581676，备注软件引言智能网联交通是继动态感知、主动管理之后智能交通系统发展至第三阶段的展现形式，在智能网联环境下的交通系统中，车辆与车辆、车辆...
• 备注：%%之间的为注释内容%%，%注释后面的内容  matlab形成自己的编程风格更有利于简洁的编程界面  图像的初步处理可应用于论文撰写上，文章更有说服力  程序调试有利于发现逻辑问题，都是必备的基础知识 %...

matlab 订阅