精华内容
下载资源
问答
  • 这段代码对内存很高,所使用图片尽量控制在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代码

    2018-03-19 18:16:51
    国外学者的开源卡尔曼滤波MATLAB代码备注详细,可以用于目标跟踪基础学习
  • 遗传算法 求解旅行商 TSP 问题,matlab代码

    万次阅读 多人点赞 2016-11-02 01:24:11
    学习启发式算法时,旅行商问题是一个经典的例子。其中,遗传算法可以用来求解该问题。遗传算法是一种进化算法,由于其启发式算法的属性,并不能保证得到最优解。求解效果与初始种群选取,编码...(备注:对于一般的 ...

    学习启发式算法时,旅行商问题是一个经典的例子。其中,遗传算法可以用来求解该问题。遗传算法是一种进化算法,由于其启发式算法的属性,并不能保证得到最优解。求解效果与初始种群选取,编码方法,选择方法,交叉变异规则有关。

    上课时,老师不知从哪里找了一个非常粗糙的程序,自己将不少错误修正,增加了一些注释方便理解,并增加了一些代码使程序更完美。该代码可以动态显示每一代的路线,非常直观! (备注:对于一般的 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

    2015-03-18 21:33:57
    SPIHT算法源代码 MATLAB版本,已经备注好了,可以直接运行使用,特别适合新手
  • 代码本人亲测调通,附代码备注。反演地表质量变化,陆地水储量变化必读代码。内附04年到10年全球的GRACE数据,海岸线数据。
  • 弹性光网络中的KSP-FF-RSA算法matlab代码,实测有效,考虑了K最短路径、首次命中以及调制格式选择,最终能输出网络阻塞率,并提供多个候选网络拓扑测试,备注超级详细。
  • 代码有详细的备注,可以帮助入门者快速熟悉遗传算法。也为需要优化遗传算法的人提供了遗传算法的框架,只需要简单修改就能完成
  • 徐大大亲自测试完成的 跳频 代码备注非常详细 适合所有用户上手。。里面详细写了跳频m序列生成 高频载波生成 各类滤波 跳频点等,欢迎大家下载
  •  代码可以复制%之间的内容(包括%)%到MATLAB里执行 一、matlab基本命令的使用 %% I. 清空环境变量及命令 clear all % 清除Workspace中的所有变量 clc % 清除Command Window中的所有命令 %% II. 变量...
  • 来源| 中国公路学报知圈 | 进“汽车软件社群”,请加微信13636581676,备注软件引言智能网联交通是继动态感知、主动管理之后智能交通系统发展至第三阶段的展现形式,在智能网联环境下的交通系统中,车辆与车辆、车辆...
  • 备注:%%之间的为注释内容%%,%注释后面的内容  matlab形成自己的编程风格更有利于简洁的编程界面  图像的初步处理可应用于论文撰写上,文章更有说服力  程序调试有利于发现逻辑问题,都是必备的基础知识 %...

空空如也

空空如也

1 2 3 4 5 6
收藏数 116
精华内容 46
关键字:

matlab备注代码

matlab 订阅