精华内容
下载资源
问答
  • matlab开发-排序特征向量初始值。对一组特征向量及其特征值进行排序
  • 转换完之后对向量进行逆序排列,我看到有同学硬是写了一个冒泡排序来完成这个工作,你的数据结构老师一定非常欣慰。但是在 MATLAB 里不用从头开始,直接调用sort()函数就行了~但是在这里还有更简单的方法,wrev()...

     其实 MATLAB 内置的函数就有diag()可以将一个对角矩阵转化为一个向量,也可以将一个向量转化为一个对角矩阵。转换完之后对向量进行逆序排列,我看到有同学硬是写了一个冒泡排序来完成这个工作,你的数据结构老师一定非常欣慰。但是在 MATLAB 里不用从头开始,直接调用sort()函数就行了~但是在这里还有更简单的方法,wrev()函数就可以将一个向量逆序排列,fliplr()函数可以将一个矩阵左右镜像对称,所以如果想得到从大到小排列的特征值,只要这样就行了:

    % 得到从大到小排列的特征值
    [V, D] = eig(A);
    lambda = wrev(diag(D));
    V = fliplr(V);

    例子:

    clear all;clc;close all;
    A=[61.45,55.9,61.95,59,58.14,53.61,55.48,54.21,61.52,54.92];
    B=[40.36,39.8,49.2,48,51.5,49.39,51.13,58.06,61,62.35];
    C=[8.61,8.91,10.43,13.32,13.48,15.75,18.14,19.95,21.95,23.53];
    D=[14.31,14.72,15.28,15.91,14.67,15,15.86,15.16,13.72,12.94];
    E=[7.67,7.75,8.15,9.24,10.68,10.58,10.31,10,8.91,8.51];
    q=[A',B',C',D',E'];
    w=cov(q);
    % 得到从大到小排列的特征值
    [V, D] = eig(w);
    lambda = wrev(diag(D));
    V1 = fliplr(V)
    
    

    转载:https://blog.csdn.net/robertchenguangzhi/article/details/40747285

    Matlab 矩阵特征值排序问题

    展开全文
  • 特征值排序问题矩阵的特征值分解矩阵的特征值分解是非常...在matlab中一般使用eig()函数完成矩阵特征值和特征向量的提取,其用法如下A = magic(4); [V,D] = eig(A);结果如下: A = 16 2 3 13 5 11 10 8 9 7 6 12

    1. 矩阵的特征值分解

    矩阵的特征值分解是非常重要的数学工具。在matlab中一般使用eig()函数完成矩阵特征值和特征向量的提取,其用法如下

    A = magic(4);
    [V,D] = eig(A);

    结果如下:

    A =
    16 2 3 13
    5 11 10 8
    9 7 6 12
    4 14 15 1
    V =
    -0.5000 -0.8236 0.3764 -0.2236
    -0.5000 0.4236 0.0236 -0.6708
    -0.5000 0.0236 0.4236 0.6708
    D =
    34.0000 0 0 0
    0 8.9443 0 0
    0 0 -8.9443 0
    0 0 0 -0.0000

    2. eig() 和 eigs()

    显然eig()就是一般意义上的计算矩阵的特征值和特征向量

    E = eig(A) 返回方阵A的所有特征值,构成列向量E。
    [V,D] = eig(A) 返回方阵A的特征值和特征向量,其中特征值排满对角阵D的对角元素,对应的特征向量排列为方阵V的每一列。

    而eigs()也能求取矩阵的特征值和特征向量,不过其返回的方阵幅值最大的6个特征值和特征向量,用法和eig()类似。不过eigs()通过迭代的方式来求解特征值,所以其在加快运算速度的同时降低了准确度。另外,一般eigs()处理的大型稀疏矩阵。

    [V,D] = eigs(A) 返回方阵A的前6个最大特征特征值和特征向量。
    [V,D] = eigs(A,k) 返回前k个最大特征值和特征向量。

    一般情况下,eig()和eigs()返回的特征值是从大到小排列,然而这并不是一定的。经过测试,两者的特征值排序都可能为乱序,所以,在对顺序有要求的情况下,需要通过sort()函数来自动排序。

    3. 使用sort()函数解决特征值排序问题

    如下

    A = magic(6);
    [V,D] = eig(A);
    [D_sort,index] = sort(diag(D),'descend');
    D_sort = D_sort(index);
    V_sort = V(:,index);

    按特征值大小排序结果如下:

    A =
    35 1 6 26 19 24
    3 32 7 21 23 25
    31 9 2 22 27 20
    8 28 33 17 10 15
    30 5 34 12 14 16
    4 36 29 13 18 11
    D =
    111.0000 0 0 0 0 0
    0 27.0000 0 0 0 0
    0 0 -27.0000 0 0 0
    0 0 0 9.7980 0 0
    0 0 0 0 0.0000 0
    0 0 0 0 0 -9.7980
    D_sort =
    111.0000
    27.0000
    -27.0000
    -9.7980
    9.7980
    0.0000

    4. Another Solution

    John D’Errico设计了一个eigenshuffle.m函数能够得到排序后的特征值和特征向量。该方法排序方式为特征值大小降序排列。
    速度测试:

    %a test by Min Qin
    A = magic(10);
    iterate = 10000;
    tic;
    for i = 1:iterate
        [V,D] = eig(A);
        [D_sort,index] = sort(diag(D),'descend');
        V_sort = V(:,index);
    end
    toc;
    tic;
    for i = 1:iterate
        [V_sort,D_sort] = eigenshuffle(A);
    end
    toc;

    结果:

    Elapsed time is 0.325471 seconds.
    Elapsed time is 0.447886 seconds.

    显然eigenshuffle函数的速度比传统方法略低。

    参考: https://cn.mathworks.com/matlabcentral/fileexchange/22885-eigenshuffle
    eigenshuffle.m代码:

    function [Vseq,Dseq] = eigenshuffle(Asequence)
    % eigenshuffle: Consistent sorting for an eigenvalue/vector sequence
    % [Vseq,Dseq] = eigenshuffle(Asequence)
    %
    % Includes munkres.m (by gracious permission from Yi Cao)
    % to choose the appropriate permutation. This greatly`这里写代码片`
    % enhances the speed of eigenshuffle over my previous
    % release.
    %
    % http://www.mathworks.com/matlabcentral/fileexchange/20652
    %
    % Arguments: (input)
    %  Asequence - an array of eigenvalue problems. If
    %      Asequence is a 3-d numeric array, then each
    %      plane of Asequence must contain a square
    %      matrix that will be used to call eig.
    %
    %      Eig will be called on each of these matrices
    %      to produce a series of eigenvalues/vectors,
    %      one such set for each eigenvalue problem.
    %
    % Arguments: (Output)
    %  Vseq - a 3-d array (pxpxn) of eigenvectors. Each
    %      plane of the array will be sorted into a
    %      consistent order with the other eigenvalue
    %      problems. The ordering chosen will be one
    %      that maximizes the energy of the consecutive
    %      eigensystems relative to each other.
    %
    %  Dseq - pxn array of eigen values, sorted in order
    %      to be consistent with each other and with the
    %      eigenvectors in Vseq.
    %
    % Example:
    %  Efun = @(t) [1 2*t+1 t^2 t^3;2*t+1 2-t t^2 1-t^3; ...
    %               t^2 t^2 3-2*t t^2;t^3 1-t^3 t^2 4-3*t];
    %
    %  Aseq = zeros(4,4,21);
    %  for i = 1:21
    %    Aseq(:,:,i) = Efun((i-11)/10);
    %  end
    %  [Vseq,Dseq] = eigenshuffle(Aseq);
    %  
    % To see that eigenshuffle has done its work correctly,
    % look at the eigenvalues in sequence, after the shuffle.
    %
    % t = (-1:.1:1)';
    % [t,Dseq']
    % ans =
    %        -1     8.4535           5      2.3447     0.20181
    %      -0.9     7.8121      4.7687      2.3728     0.44644
    %      -0.8     7.2481        4.56      2.3413     0.65054
    %      -0.7     6.7524      4.3648      2.2709      0.8118
    %      -0.6     6.3156      4.1751      2.1857     0.92364
    %      -0.5     5.9283      3.9855      2.1118     0.97445
    %      -0.4     5.5816      3.7931      2.0727     0.95254
    %      -0.3     5.2676      3.5976      2.0768       0.858
    %      -0.2     4.9791      3.3995      2.1156     0.70581
    %      -0.1     4.7109         3.2      2.1742     0.51494
    %         0     4.4605           3      2.2391     0.30037
    %       0.1     4.2302         2.8      2.2971    0.072689
    %       0.2     4.0303      2.5997      2.3303    -0.16034
    %       0.3     3.8817      2.4047      2.3064    -0.39272
    %       0.4     3.8108      2.1464      2.2628    -0.62001
    %       0.5     3.8302      1.8986      2.1111    -0.83992
    %       0.6     3.9301      1.5937      1.9298     -1.0537
    %       0.7     4.0927      1.2308       1.745     -1.2685
    %       0.8     4.3042     0.82515      1.5729     -1.5023
    %       0.9     4.5572     0.40389      1.4272     -1.7883
    %         1     4.8482  -8.0012e-16     1.3273     -2.1755
    %
    % Here, the columns are the shuffled eigenvalues.
    % See that the second eigenvalue goes to zero, but
    % the third eigenvalue remains positive. We can plot
    % eigenvalues and see that they have crossed, near
    % t = 0.35 in Efun.
    %
    % plot(-1:.1:1,Dseq')
    %
    % For a better appreciation of what eigenshuffle did,
    % compare the result of eig directly on Efun(.3) and
    % Efun(.4). Thus:
    %
    % [V3,D3] = eig(Efun(.3))
    % V3 =
    %     -0.74139      0.53464     -0.23551       0.3302
    %      0.64781       0.4706     -0.16256      0.57659
    %    0.0086542     -0.44236     -0.89119      0.10006
    %     -0.17496     -0.54498      0.35197      0.74061
    %
    % D3 =
    %     -0.39272            0            0            0
    %            0       2.3064            0            0
    %            0            0       2.4047            0
    %            0            0            0       3.8817
    %
    % [V4,D4] = eig(Efun(.4))
    % V4 =
    %     -0.73026      0.19752      0.49743      0.42459
    %      0.66202      0.21373      0.35297      0.62567
    %     0.013412     -0.95225      0.25513      0.16717
    %     -0.16815    -0.092308     -0.75026      0.63271
    %
    % D4 =
    %     -0.62001            0            0            0
    %            0       2.1464            0            0
    %            0            0       2.2628            0
    %            0            0            0       3.8108
    %
    % With no sort or shuffle applied, look at V3(:,3). See
    % that it is really closest to V4(:,2), but with a sign
    % flip. Since the signs on the eigenvectors are arbitrary,
    % the sign is changed, and the most consistent sequence
    % will be chosen. By way of comparison, see how the
    % eigenvectors in Vseq have been shuffled, the signs
    % swapped appropriately.
    %
    % Vseq(:,:,14)
    % ans =
    %       0.3302      0.23551     -0.53464      0.74139
    %      0.57659      0.16256      -0.4706     -0.64781
    %      0.10006      0.89119      0.44236   -0.0086542
    %      0.74061     -0.35197      0.54498      0.17496
    %
    % Vseq(:,:,15)
    % ans =
    %      0.42459     -0.19752     -0.49743      0.73026
    %      0.62567     -0.21373     -0.35297     -0.66202
    %      0.16717      0.95225     -0.25513    -0.013412
    %      0.63271     0.092308      0.75026      0.16815
    %
    % See also: eig
    %
    % Author: John D'Errico
    % e-mail: woodchips@rochester.rr.com
    % Release: 3.0
    % Release date: 2/18/09
    
    % Is Asequence a 3-d array?
    Asize = size(Asequence);
    if (Asize(1)~=Asize(2))
      error('Asequence must be a (pxpxn) array of eigen-problems, each of size pxp')
    end
    p = Asize(1);
    if length(Asize)<3
      n = 1;
    else
      n = Asize(3);
    end
    
    % the initial eigenvalues/vectors in nominal order
    Vseq = zeros(p,p,n);
    Dseq = zeros(p,n);
    for i = 1:n
      [V,D] = eig(Asequence(:,:,i));
      D = diag(D);
      % initial ordering is purely in decreasing order.
      % If any are complex, the sort is in terms of the
      % real part.
      [junk,tags] = sort(real(D),1,'descend');
    
      Dseq(:,i) = D(tags);
      Vseq(:,:,i) = V(:,tags);
    end
    
    % was there only one eigenvalue problem?
    if n < 2
      % we can quit now, having sorted the eigenvalues
      % as best as we could.
      return
    end
    
    % now, treat each eigenproblem in sequence (after
    % the first one.)
    for i = 2:n
      % compute distance between systems
      V1 = Vseq(:,:,i-1);
      V2 = Vseq(:,:,i);
      D1 = Dseq(:,i-1);
      D2 = Dseq(:,i);
      dist = (1-abs(V1'*V2)).*sqrt( ...
        distancematrix(real(D1),real(D2)).^2+ ...
        distancematrix(imag(D1),imag(D2)).^2);
    
      % Is there a best permutation? use munkres.
      % much faster than my own mintrace, munkres
      % is used by gracious permission from Yi Cao.
      reorder = munkres(dist);
    
      Vseq(:,:,i) = Vseq(:,reorder,i);
      Dseq(:,i) = Dseq(reorder,i);
    
      % also ensure the signs of each eigenvector pair
      % were consistent if possible
      S = squeeze(real(sum(Vseq(:,:,i-1).*Vseq(:,:,i),1))) < 0;
      Vseq(:,S,i) = -Vseq(:,S,i);
    end
    
    % =================
    % end mainline
    % =================
    % begin subfunctions
    % =================
    
    function d = distancematrix(vec1,vec2)
    % simple interpoint distance matrix
    [vec1,vec2] = ndgrid(vec1,vec2);
    d = abs(vec1 - vec2);
    
    function [assignment,cost] = munkres(costMat)
    % MUNKRES   Munkres (Hungarian) Algorithm for Linear Assignment Problem. 
    %
    % [ASSIGN,COST] = munkres(COSTMAT) returns the optimal column indices,
    % ASSIGN assigned to each row and the minimum COST based on the assignment
    % problem represented by the COSTMAT, where the (i,j)th element represents the cost to assign the jth
    % job to the ith worker.
    %
    
    % This is vectorized implementation of the algorithm. It is the fastest
    % among all Matlab implementations of the algorithm.
    
    % Examples
    % Example 1: a 5 x 5 example
    %{
    [assignment,cost] = munkres(magic(5));
    disp(assignment); % 3 2 1 5 4
    disp(cost); %15
    %}
    % Example 2: 400 x 400 random data
    %{
    n=400;
    A=rand(n);
    tic
    [a,b]=munkres(A);
    toc                 % about 2 seconds 
    %}
    % Example 3: rectangular assignment with inf costs
    %{
    A=rand(10,7);
    A(A>0.7)=Inf;
    [a,b]=munkres(A);
    %}
    % Reference:
    % "Munkres' Assignment Algorithm, Modified for Rectangular Matrices", 
    % http://csclab.murraystate.edu/bob.pilgrim/445/munkres.html
    
    % version 2.0 by Yi Cao at Cranfield University on 10th July 2008
    
    assignment = zeros(1,size(costMat,1));
    cost = 0;
    
    costMat(costMat~=costMat)=Inf;
    validMat = costMat<Inf;
    validCol = any(validMat,1);
    validRow = any(validMat,2);
    
    nRows = sum(validRow);
    nCols = sum(validCol);
    n = max(nRows,nCols);
    if ~n
        return
    end
    
    maxv=10*max(costMat(validMat));
    
    dMat = zeros(n) + maxv;
    dMat(1:nRows,1:nCols) = costMat(validRow,validCol);
    
    %*************************************************
    % Munkres' Assignment Algorithm starts here
    %*************************************************
    
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    %   STEP 1: Subtract the row minimum from each row.
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    minR = min(dMat,[],2);
    minC = min(bsxfun(@minus, dMat, minR));
    
    %**************************************************************************  
    %   STEP 2: Find a zero of dMat. If there are no starred zeros in its
    %           column or row start the zero. Repeat for each zero
    %**************************************************************************
    zP = dMat == bsxfun(@plus, minC, minR);
    
    starZ = zeros(n,1);
    while any(zP(:))
        [r,c]=find(zP,1);
        starZ(r)=c;
        zP(r,:)=false;
        zP(:,c)=false;
    end
    
    while 1
    %**************************************************************************
    %   STEP 3: Cover each column with a starred zero. If all the columns are
    %           covered then the matching is maximum
    %**************************************************************************
        if all(starZ>0)
            break
        end
        coverColumn = false(1,n);
        coverColumn(starZ(starZ>0))=true;
        coverRow = false(n,1);
        primeZ = zeros(n,1);
        [rIdx, cIdx] = find(dMat(~coverRow,~coverColumn)==bsxfun(@plus,minR(~coverRow),minC(~coverColumn)));
        while 1
            %**************************************************************************
            %   STEP 4: Find a noncovered zero and prime it.  If there is no starred
            %           zero in the row containing this primed zero, Go to Step 5.  
            %           Otherwise, cover this row and uncover the column containing 
            %           the starred zero. Continue in this manner until there are no 
            %           uncovered zeros left. Save the smallest uncovered value and 
            %           Go to Step 6.
            %**************************************************************************
            cR = find(~coverRow);
            cC = find(~coverColumn);
            rIdx = cR(rIdx);
            cIdx = cC(cIdx);
            Step = 6;
            while ~isempty(cIdx)
                uZr = rIdx(1);
                uZc = cIdx(1);
                primeZ(uZr) = uZc;
                stz = starZ(uZr);
                if ~stz
                    Step = 5;
                    break;
                end
                coverRow(uZr) = true;
                coverColumn(stz) = false;
                z = rIdx==uZr;
                rIdx(z) = [];
                cIdx(z) = [];
                cR = find(~coverRow);
                z = dMat(~coverRow,stz) == minR(~coverRow) + minC(stz);
                rIdx = [rIdx(:);cR(z)];
                cIdx = [cIdx(:);stz(ones(sum(z),1))];
            end
            if Step == 6
                % *************************************************************************
                % STEP 6: Add the minimum uncovered value to every element of each covered
                %         row, and subtract it from every element of each uncovered column.
                %         Return to Step 4 without altering any stars, primes, or covered lines.
                %**************************************************************************
                [minval,rIdx,cIdx]=outerplus(dMat(~coverRow,~coverColumn),minR(~coverRow),minC(~coverColumn));            
                minC(~coverColumn) = minC(~coverColumn) + minval;
                minR(coverRow) = minR(coverRow) - minval;
            else
                break
            end
        end
        %**************************************************************************
        % STEP 5:
        %  Construct a series of alternating primed and starred zeros as
        %  follows:
        %  Let Z0 represent the uncovered primed zero found in Step 4.
        %  Let Z1 denote the starred zero in the column of Z0 (if any).
        %  Let Z2 denote the primed zero in the row of Z1 (there will always
        %  be one).  Continue until the series terminates at a primed zero
        %  that has no starred zero in its column.  Unstar each starred
        %  zero of the series, star each primed zero of the series, erase
        %  all primes and uncover every line in the matrix.  Return to Step 3.
        %**************************************************************************
        rowZ1 = find(starZ==uZc);
        starZ(uZr)=uZc;
        while rowZ1>0
            starZ(rowZ1)=0;
            uZc = primeZ(rowZ1);
            uZr = rowZ1;
            rowZ1 = find(starZ==uZc);
            starZ(uZr)=uZc;
        end
    end
    
    % Cost of assignment
    rowIdx = find(validRow);
    colIdx = find(validCol);
    starZ = starZ(1:nRows);
    vIdx = starZ <= nCols;
    assignment(rowIdx(vIdx)) = colIdx(starZ(vIdx));
    cost = trace(costMat(assignment>0,assignment(assignment>0)));
    
    function [minval,rIdx,cIdx]=outerplus(M,x,y)
    [nx,ny]=size(M);
    minval=inf;
    for r=1:nx
        x1=x(r);
        for c=1:ny
            M(r,c)=M(r,c)-(x1+y(c));
            if minval>M(r,c)
                minval=M(r,c);
            end
        end
    end
    [rIdx,cIdx]=find(M==minval);
    展开全文
  • 线性代数中最核心的一个操作是解不同的矩阵方程,包括解线性方程组和特征向量等。在传统计算机上,解矩阵方程需要一些精心设计的算法,如高斯消元法、LU分解法,然后在多项式时间内(比如O(N3),N是矩阵行/列数)获得...
    974b12eb03569624df6742c4bbf19bfd.png

    线性代数存在于几乎所有的科学和工程领域,比如统计学、物理学、信号处理,和机器学习。线性代数中最核心的一个操作是解不同的矩阵方程,包括解线性方程组和特征向量等。在传统计算机上,解矩阵方程需要一些精心设计的算法,如高斯消元法、LU分解法,然后在多项式时间内(比如O(N3),N是矩阵行/列数)获得方程解。

    在大数据时代,人们要处理的数据呈爆发式增长,而很多数据处理本质是一个矩阵方程问题,如谷歌的网页排序(PageRank算法)、利用超级计算机模拟量子效应(解薛定谔方程)。随着摩尔定律的失效,以及由于冯诺依曼架构存储、计算分离的固有限制,想更快、更省地完成数据处理变得越来越难,而计算的时间和能耗效率在大数据时代显得尤为重要。

    近年来,存内计算(in-memory computing)兴起,通过在存储单元内完成计算将显著提高计算效率。一个典型的存内计算例子是利用阻变存储器(或称忆阻器)的交叉阵列一步完成矩阵-向量乘法的运算,从而快速完成包括训练神经网络在内的大数据任务。然而,一步解矩阵方程,如线性方程组Ax = b,仍然是一个挑战。在我们最新的PNAS文章里,我们报道了利用交叉存储阵列,通过引入反馈电路,可以一步解线性方程组和矩阵的特征向量,进而实现一步解微分方程,包括傅里叶方程、薛定谔方程,和一步完成谷歌的网页排序。

    对于解线性方程组Ax = b,我们采用的电路如图1(a)所示。电路中包含了一个交叉存储阵列,阵列中每一个行线和列线之间有一个阻变存储器件,它的电导值一一对应于矩阵中的一个元素值。已知向量b由行线的输入电流表示,通过运算放大器(运放)引入的负反馈机制将使行线虚接地,从而列线上运放的输出电压可以表示未知向量x的解值。由于矩阵A以非易失的形式存储在交叉阵列中,一旦施加输入电流,相应的线性方程组就能一步得到解答。实验中,我们存储的矩阵A如图1(a)所示。图1(b)给出了一个相应的线性方程组的实验解,以及它的解析解。可以看到,实验解十分接近解析解(相对误差在3%),从而证明了我们方案的可行性。逆矩阵也是线性代数中一项非常重要的内容,它也可以通过求解多个线性方程组获得,实验解和解析解的比较如图1(c)所示。

    7716b1f8836a6daabe705a8be7ad6679.png

    图1. 线性方程组求解电路及求解结果。

    阻变存储器件的电导值只能为正数,因此图1(a)的电路只适用于解系数为正的线性方程组。为了使我们的方案具有普适性,即,解任意实数的线性方程组,我们进一步拓展了电路,如图2(a)所示。图中利用了两个交叉阵列和反相器,实现了两个正矩阵之间的差,从而能够代表任意实数矩阵。基于该普适的线性方程组求解电路,利用有限差分法,我们求解了一个微分方程。如图2(b)所示,在两个电极之间施加一个电压,电极之间导线上的温度分布可以用一维静态傅里叶方程来描述。图2(c)给出了该微分方程的电路解,可以发现与方程的解析解完美重合,从而证明了我们的电路用于快速求解实际问题的可靠性。

    f82fd73d698920bc268f44feb11b25f2.png

    图2. 针对任意实数矩阵的线性方程组求解电路,及求解热传导的一维傅里叶方程。

    基于交叉存储阵列和运放的负反馈机制,我们还能求解矩阵方程Ax = λx,λ为矩阵的特征值,x为相应的特征向量。电路如图3(a)所示,矩阵A依然由交叉阵列表示,λ由跨阻放大器的跨导表示,反相器的输出电压即为待解的x,从而实现一步求解特征向量。需要注意的是,图3(a)电路用于求解正特征值的特征向量,而假如求解负特征值的特征向量,将反相器移去即可,负特征值的绝对值依然由跨阻放大器的跨导表示。和线性方程组求解电路一样,特征向量求解电路也可以拓展到任意实数矩阵。谷歌公司的网页排序算法(PageRank)本质上就是求解一个随机矩阵的最大特征值的特征向量,因此,我们的电路可以用于一步实现网页排序,而不需要繁复的迭代算法,从而为搜索引擎提供加速。图3(b)表示了各科技巨头公司的Wikipedia网页之间的连接情况(网页i指向网页j代表网页i引用网页j),图3(c)则给出了电路解的排序结果和解析解之间的比较,可以发现二者排序一致。

    ffee8c92f147b5b0ec4a7e570aa11d6c.png

    图3. 特征向量求解电路及PageRank。

    薛定谔方程HΨ = EΨ是量子力学的基础,为了获得一个量子系统的波函数分布,必须求解相应的薛定谔方程。作为一个微分方程,薛定谔方程可以通过有限差分法转化为一个特征向量问题。图4(a)是一个一维量子势阱,为了求解它的基态波函数,我们将待求解的波函数离散化,从而将哈密顿量H 转化为一个矩阵,基态能量E 则是最小特征值(负数),而离散化Ψ则是待求解的特征向量。图4(b)给出了该波函数的电路解,可以看到它很好地描述了一维量子势阱基态的波函数分布,因此证明了我们的电路具有很大的潜力用于加速模拟量子系统,比如在新型材料合成和新型药物开发等领域。

    09cb4b349ed1fcbb7e06140718763eb0.png

    图4. 利用特征向量求解电路解一维量子势阱的基态波函数。

    在我们的工作中,通过利用非易失的阻变存储器(忆阻器)交叉阵列和引入负反馈机制,常见的线性代数问题,包括解线性方程组、解特征向量、解微分方程可以在一步内完成,从而显著提高计算速度,同时降低计算能耗,为未来的存内计算系统应用于实际的大数据问题中打下了坚实基础。

    该工作由来自意大利米兰理工大学的一支团队完成,团队专注于利用新型存储器件加速传统计算和机器学习的开发。孙仲博士为论文的第一作者,Daniele Ielmini教授为论文的通讯作者。

    展开全文
  • MATLAB中SVM的特征重要性排序

    千次阅读 2018-12-01 21:19:07
    MATLAB中可以通过支持向量机递归特征消除(Support Vector Machine Recursive Feature Elimination :SVM-RFE)来获得SVM的特征重要性排序!!! SVM-RFE算法是根据SVM在训练时生成的权向量w来构造排序...

    MATLAB中可以通过支持向量机递归特征消除(Support Vector Machine Recursive Feature Elimination :SVM-RFE)来获得SVM的特征重要性排序!!!

    SVM-RFE算法是根据SVM在训练时生成的权向量w来构造排序系数,每次迭代去掉一个排序系数最小的特征属性,最终得到所有特征属性的递减顺序的排序。
    经典的SVM-RFE采用的是线性核函数,推广到非线性情况,这里我们采用的是RBF核函数,此时采用的排序系数为:

    整体SVM-RFE(RBF核)算法过程如下:

    在每一次循环中,具有最小排序系数的特征将被移除,然后SVM对剩余的特征重新训练以获取新的排序系数。SVM-RFE方法通过迭代执行这一过程,最后得到一个特征排序表,利用该排序列表,定义若干个嵌套的特征子集 来训练SVM,并以SVM的预测正确率评估这些子集的优劣,从而获得最优的特征子集。需要注意的是,排在前面的那些特征,单个并不一定使得SVM分类器获得最好的分类性能,而是多个特征组合在一起,才使得分类器获得最优的分类性能,因此,SVM-RFE算法能选择出互补的特征组合。

    在选择最佳特征子集的过程中,我们采用训练集留一交叉检验错误识别率(LooErrorRate)和独立测试集错误识别率(TestErrorRate)两个指标来综合判定最佳的特征子集。由于采用RBF核函数,这就涉及到参数的选取设定(惩罚因子c和RBF核函数参数 ),在SVM-RFE确定特征排序表过程和训练集留一交叉检验过程中,采用固定的参数组 ,在独立测试集识别过程中将使用网格寻参(grid search)的方法来进行参数寻优。整体确定最佳特征子集过程如下表所示:

    SVM-RFE 代码实现

    
    function r = SVMRFE(label, data)
    % SVM-RFE
    % SVM Recursive Feature Elimination (SVM RFE)
    % by liyang @BNU Math
    % Email:patrick.lee@foxmail.com
    % last modified 2010.09.18
    %%
    n = size(data,2);
    s = 1:n;
    r = [];
    iter = 1;
    while ~isempty(s)
    %     if mod(iter, 10) == 0
    %         str = ['===',num2str(iter),'==='];
    %         disp(str);
    %         disp('processing .....');
    %     end
        X = data(:,s);
        
    %     v = 3;
    %     [bestCVaccuracy,bestc,bestg] = SVMcgForClass(label, X, ...
    %         -8,8,-8,8,v,0.8,0.8,4.5);
    %     cmd = ['-c ',num2str(bestc),' -g ',num2str(bestg)];
    %     model = svmtrain(label, X, cmd);
        
        model = svmtrain(label, X);
        
        w = model.SVs' * model.sv_coef;
        c = w.^2;
        [c_minvalue, f] = min(c);
        r = [s(f),r];
        ind = [1:f-1, f+1:length(s)];
        s = s(ind);
        
        iter = iter + 1;
    end
    

    该程序需要用到以下工具箱:
    Libsvm-mat faruto版本下载
    libsvm-mat-2.89-3[FarutoUltimate3.0]
    http://www.matlabsky.com/thread-9327-1-1.html

    ===================================================
    更多关于SVM的最新整理帖子请看:
    关于SVM的那点破事[长期更新整理 by faruto]
    http://www.matlabsky.com/thread-10966-1-1.html

    相关参考资料:


    SVM-RFE相关文献.rar (1.38 MB, 下载次数: 68741)

    ===================================================
    MATLAB 神经网络30个案例分析》视频销售官方地址:
    http://video.ourmatlab.com/
    视频销售客服QQ:1007911579
    ===================================================
    《MATLAB 神经网络30个案例分析》购买方式:
    当当网:
    http://product.dangdang.com/prod ... mp;ref=search-1-pub
    China-Pub:
    http://www.china-pub.com/50688
    卓越网:
    http://www.amazon.cn/mn/detailAp ... 03HGHB9W&sr=8-1
    ===================================================

    转自http://www.matlabsky.com/forum-viewthread-tid-11568-fromuid-18677.html

    展开全文
  • matlab开发-Eigenshuffle

    2019-08-24 16:04:23
    matlab开发-Eigenshuffle。一致排序的特征值和特征向量序列
  • matlab开发-Eigenshuffle2

    2019-08-27 12:09:43
    matlab开发-Eigenshuffle2。排序特征值和特征向量的函数
  • Matlab 编程实现主成分分析 . 程序结构及函数作用 在软件 Matlab 中实现主成分分析可以...函数作用用总和标准化法标准化矩阵 计算相关系数矩阵 计算特征值和特征向量 对主成分进行排序 计算 各特征值贡献率挑选主成分累
  • matlab下调用python,numpy库函数的方法

    千次阅读 2018-12-06 15:49:39
    博主在用matlab下的eig函数计算正定阵特征值和特征向量时,得到的特征值被排序了(非正定阵不会排序),且matlab还不返回特征值没有排序时候的位置索引,而笔者很需要这个索引。而我用python计算正定阵特征值时,...
  • matlab基于Hu不变矩的图像...纹理特征和颜色矩特征都是一维向量,检索的时候分别计算待检索图像和mat文件中颜色矩和纹理特征向量的欧几里得距离,并给予不同的权值。对这些距离进行升序排序,这样就得到了图像检索结果.
  • 正确使用Matlab中的PCA包

    千次阅读 2018-03-14 14:25:11
    coeff :特征向量,每一列表示一个特征向量。并以特征值从大到小排了序 score :新的数据表示,行表示样本,列表示样本属性。(与X一样) latent :特征值,并以从大到小排序。可根据每个值...
  • condeig 计算特征值、特征向量同时给出条件数 condest 范 -1条件数估计 conj 复数共轭 contour 等位线 contourf 填色等位线 contour3 三维等位线 contourslice 四维切片等位线图 conv 多项式乘、卷积 cool ...
  • 使用matlab中PCA包进行训练集与测试集处理1. matlab中PCA包的使用与分析2....coeff :特征向量。每一列表示一个特征向量。并按特征值从大到小排序 score :新数据。使用PCA后的数据表示,大小和X一致
  • matlab命令手册pdf

    2011-05-23 20:39:36
    8.1 特征值和特征向量的计算 113 8.2 上海森伯形式、QR和QZ因式分解 117 8.3 舒尔分解和奇异值分解 119 第9章 稀疏矩阵 123 9.1 矩阵为什么稀疏 123 9.2 创建和转换稀疏矩阵 123 9.3 稀疏矩阵运算 126 9.4 稀疏矩阵...
  • 主成分分析Matlab程序设计

    千次阅读 2015-07-19 22:58:15
    (3)计算相关系数矩阵R的特征值和相应的特征向量 (4)选择重要的主成分,写出主成分表达式 案例问题:企业综合实力排序 企业综合实力评价表: 企业序号 净利润率/% 固定资产利润率/% 总产值利润...
  • MATLAB函数参考

    2012-03-19 20:43:56
    matlab函数网上搜集并精心整理,添加了目录,便于查阅。共23页。 文档内容举例: 函数名 功能描述 addpath 增加一条搜索路径 目 录 1 常用命令 1.1 管理用命令 1.2管理变量与工作空间用命令 1.3文件与操作系统...
  • K最邻近密度估计技术是一种分类方法,不是聚类方法。 不是最优方法,实践中比较流行。 通俗但不一定易懂的规则是: 1.计算待分类数据和不同类中每一个数据的...给定一个位置特征向量x和一种距离测量方法,于是有...
  • %对J 排序,找到前两个最大值。 a=I(:,3);b=I(:,2); U=[V(:,a) V(:,b)];% 选择最大的个特征值对应的特征矢量作出变换矩阵 U=U' Y=U*X2; %Y=Y'; Y1=Y(:,1:200); Y2=Y(:,201:390); Y3=Y(:,391:600); Y1=Y1'; Y2=Y2'; ...
  • //用burte force进行匹配特征向量 BruteForceMatcher<L2<float>>matcher;//定义一个burte force matcher对象 vector<DMatch>matches; matcher.match(descriptors_1,descriptors_2,matches); //提取出前15个...
  • 3.4.3 特征值和特征向量 3.5 稀疏矩阵 3.5.1 稀疏矩阵的存储方式 3.5.2 稀疏矩阵的生成 3.5.3 稀疏矩阵的运算 3.6 本章小结 第4 章MATLAB 编程基础 4.1 M 文件编辑器 4.2 变量 4.2.1 变量的命名 ...
  • 3.4.3 特征值和特征向量 3.5 稀疏矩阵 3.5.1 稀疏矩阵的存储方式 3.5.2 稀疏矩阵的生成 3.5.3 稀疏矩阵的运算 3.6 本章小结 第4 章MATLAB 编程基础 4.1 M 文件编辑器 4.2 变量 4.2.1 变量的命名 ...
  • 带精英策略的快速非支配排序遗传算法(Nondominated Sorting Genetic Algorithm II,NSGA-II)是目前应用较为广泛的一种多目 标算法。本案例将对MATLAB自带的改进的NSGA-II进行讲解,并举例说明其应用。 10 基于多...
  • 根据相应的特征值把特征向量从大到小排序,从组成的矩阵选取K行代表降维的基(K维); 6.降维的基和原有数据X相乘,即为降维后的数据Y 2、MATLAB实现3、python实现#pca import numpy as np#零均值化 def zeroM
  • “ 在深度模型没有盛行之前,基于传统局部特征(SIFT,SURF)的方案是图像分类和检索领域的主流。以基于内容的图像检索为例,...传统方案是对每张图像抽取多个局部特征然后再将其聚合成单个紧致向量,得到的向量便可...
  • 每日一记录

    2015-06-24 21:16:47
    目前成果:MATLAB 编码实现简单界面的搜索,提取了图像的底层特征,颜色,形状,纹理,融合了三种图像特征作为特征向量,根据距离算法,计算相似性度量,排序输出搜索到的图像。 想法:14年选论文题目时候,就打算...
  • 层次分析法(Analytic Hierarchy Process):将半定性半定量问题转化为定量问题。 适用于难以完全定量分析的复杂问题,...需要用matlab将评判矩阵转化为因素的权重矩阵,做法:求解矩阵的最大特征根,对应阵向量。 ...
  • STM32中NVIC(嵌套向量中断控制)的理解 STM32串口通信记 STM32复位和系统时钟 STM32用作编码器接口的原理 TI-DSP数学库之c67xmathlib的使用 TMS320C6713烧写Flash的通用方法 使用Tcl脚本分配FPGA管脚 在DSP671x上使用...
  • LSHBOX:局部敏感算法(LSH)的C++工具箱,提供了好几种普遍的LSH算法,也可以支持Python和MATLAB。 PGM-index:能够快速查找、前导、范围搜索和更新数以亿计项数组的数据结构,其跟传统索引相比,使用梯度的顺序而...

空空如也

空空如也

1 2
收藏数 30
精华内容 12
关键字:

matlab特征向量排序

matlab 订阅