modlgui.m

PLS_Toolbox是用于故障检测与诊断方面的matlab工具箱

    set(f2(3,1),'String',int2str(modl.iter))
  case 'exitmodl'
    %check to see if data edited, if so ask if save
    %check to see if model changed, if so ask if save
    delfigs(as)
    figure(p2),closereq
    figure(a), closereq
  %Button Callbacks
  case 'calculate'
    delfigs(as)
    x          = get(f(1,1),'UserData');
    y          = get(f(7,1),'UserData');
    if ~isempty(x)&~isempty(y)
      if ~isempty(modl)
        if ~isempty(modl.drow)
          jk   = [];
          for jj=1:length(modl.drow)
            jk = [jk,find(modl.irow==modl.drow(jj))];
          end
          modl.irow = delsamps(modl.irow',jk)';
        end
        x      = x(modl.irow,modl.icol);
        y      = y(modl.irow,:);
        set(bb(8,1),'Enable','on');               %save model menu
        [m,nx] = size(x);
        ny     = size(y,2);
        modl.meanx       = mean(x);
        modl.meany       = mean(y);
        modl.stdx        = std(x);
        modl.stdy        = std(y);
        switch modl.scale                         %Scaling
        case 'mean'                               %mean center
          x    = mncn(x);
          y    = mncn(y);
          mc   = 1;
        case 'auto'                               %autoscale
          x    = auto(x);
          y    = auto(y);
          mc   = 1;
        otherwise                                 %no scaling
          mc   = 0;
        end
        maxlv            = round(get(e2(1,1),'Value'));
        [ps,modl.press,modl.rmsecv,modl.rmsec]  = crossval(x,y, ...
          modl.name,modl.cv,maxlv,modl.split,modl.iter,mc,0);
        if strcmp(modl.scale,'auto')              %Scaling
          modl.press     = modl.press.*(modl.stdy(ones(maxlv,1),:).^2)'*m;
          modl.rmsecv    = modl.rmsecv.*(modl.stdy(ones(maxlv,1),:))';
          modl.rmsec     = modl.rmsec.*(modl.stdy(ones(maxlv,1),:))';
        end
 
        if size(y,2)>1
          [ps,minlv]     = min(sum(modl.press)');
        else
          [ps,minlv]     = min(modl.press');
        end
        switch modl.name
        case 'nip'
          [modl.reg,modl.ssq,p,q,w,t] = pls(x,y,maxlv,0);
          set(e(2,1),'UserData',w)
          set(e(3,1),'UserData',modl.reg)
          set(e(6,1),'UserData',q)
          modl.wts  = w(:,1:minlv);
          set(f(3,1),'UserData',p)
        case 'sim'
          [modl.reg,modl.ssq,p,q,r,t] = simpls(x,y,maxlv,[],0);
          set(e(2,1),'UserData',r)
          set(e(3,1),'UserData',modl.reg)
          set(e(6,1),'UserData',q)
          modl.wts  = r(:,1:minlv);
          set(f(3,1),'UserData',p)
          for ii=1:minlv
            t(:,ii) = t(:,ii)*norm(p(:,ii));
            p(:,ii) = p(:,ii)/norm(p(:,ii));
          end
        case 'pcr'
          [modl.reg,modl.ssq,t,p] = pcr(x,y,maxlv,0);
          set(e(2,1),'UserData',[])
          set(e(3,1),'UserData',modl.reg)
          set(e(6,1),'UserData',[])
          modl.wts  = [];
          set(f(3,1),'UserData',p)
        end
        s           = (minlv-1)*ny;
        set(e2(1,1),'UserData',modl.reg)
        modl.reg    = modl.reg(s+1:s+ny,:)';  %Regression vector(s)
        switch modl.scale
        case 'mean'
          modl.ypred  = rescale(x*modl.reg,modl.meany);
          modl.yres   = modl.ypred-rescale(y,modl.meany);
        case 'auto'
          modl.ypred  = rescale(x*modl.reg,modl.meany,modl.stdy);
          modl.yres   = modl.ypred-rescale(y,modl.meany,modl.stdy);
        otherwise
          modl.ypred  = x*modl.reg;
          modl.yres   = modl.ypred-y;
        end
        t           = t(:,1:minlv);
        p           = p(:,1:minlv);
        %Sample residuals Q
        if minlv<min([m nx])
          resmat = x - t*p';
          modl.res    = sum(resmat.^2,2);
          if m > nx
            covr = (resmat'*resmat)/(m-1);
          else
            covr = (resmat*resmat')/(m-1);
          end
          emod = svd(covr);
          emod = emod(1:length(emod)-minlv);
		  modl.reseig = emod;
          modl.reslim = reslim(0,emod,95);
        else
          modl.res = zeros(m,1);
          modl.reslim = 0;
		  modl.reseig = [];
        end
        %T^2 and Limit
        ps          = 1./sqrt(diag(t'*t)/(m-1));
        modl.tsq    = t*diag(ps);
        if minlv>1
          modl.tsq  = sum((modl.tsq.^2)')';
        else
          modl.tsq  = modl.tsq.^2;
        end
        modl.tsqlim = tsqlim(m,minlv,95); %95% confidence limit for T^2
        modl.date   = date;               %date model was created
        modl.time   = clock;              %time model was created
        modl.xname  = get(d(4,1),'UserData');
        modl.yname  = get(f(6,1),'UserData');
        modl.scores = t;                  %Scores
        modl.samps  = m;                  %Number of samples in (data)
        modl.loads  = p;                  %Loadings
        %modl.lev    = diag(t*diag(1./diag(t'*t))*t'); %Leverage
        modl.lev    = sum(t'.*(diag(1./diag(t'*t))*t'),1)';
        p           = ones(m,1)-modl.lev;
        p           = p(:,ones(1,ny));
        ps          = sqrt(diag(modl.yres'*(modl.yres./(p.^2)))/(m-1))';
        modl.yres   = modl.yres./(ps(ones(m,1),:).*sqrt(p));
        set(e(5,1),'UserData',modl.yres)
        clear x y t m p w maxlv ps
        format = get(e(1,1),'UserData');
        s      = [];
        ps     = str2num(get(f2(1,1),'String'));
        for jj=1:min([size(modl.ssq,1); 40])
          s    = [s;sprintf(format,modl.ssq(jj,:))];
        end
        set(f(4,1),'UserData',minlv);
        set(e(3,1),'String',int2str(minlv))
        set(e(4,1),'String',s,'Value',minlv)
        stat.data = 'cal';
        stat.modl = 'calold';
      else
        stat.modl = 'none';
      end
    else
      stat.data   = 'none';
    end
    set(bb(12,1),'Enable','off')
  case 'apply'
    delfigs(as)
    if strcmp(stat.modl,'calnew')
      if ~isempty(modl.drow)
        jk   = [];
        for jj=1:length(modl.drow)
          jk = [jk,find(modl.irow==modl.drow(jj))];
        end
        modl.irow = delsamps(modl.irow',jk)';
      end
      x     = x(modl.irow,modl.icol);
      y     = y(modl.irow,:);
    end
    [mx,nx] = size(x);
    ny      = size(y,2);
    m       = size(modl.loads,1);
    if nx~=m
      erdlgpls('Error- num vars in x ~= num rows of loads ', ...
        'Error on Apply');
    else
      switch modl.scale                         %scale x but not y
      case 'mean'
        x     = scale(x,modl.meanx);
      case 'auto'
        x     = scale(x,modl.meanx,modl.stdx);
      end
      m     = get(f(4,1),'UserData');           %number of LVs
      if ~strcmp(stat.modl,'loaded')
        p           = get(f(3,1),'UserData');
        modl.loads  = p(:,1:m);                 %Loadings
        switch lower(modl.name)
        case 'nip'
          w         = get(e(2,1),'UserData');
          modl.wts  = w(:,1:m);
          xhat      = x;
          modl.scores = zeros(mx,m);
          for ii=1:m
            modl.scores(:,ii) = xhat*modl.wts(:,ii);
            xhat    = xhat - modl.scores(:,ii)*modl.loads(:,ii)';
          end
        case 'sim'
          r         = get(e(2,1),'UserData');
		      modl.wts = r(:,1:m);
          modl.scores = x*r;
          for ii=1:m
            modl.scores(:,ii) = modl.scores(:,ii)*norm(p(:,ii));
            modl.loads(:,ii)  = p(:,ii)/norm(p(:,ii));
          end
          modl.scores = modl.scores(:,1:m);
        case 'pcr'
          modl.scores = x*modl.loads;
        end
        modl.reg    = get(e2(1,1),'UserData');
        modl.reg    = modl.reg(ny*(m-1)+1:ny*m,:)';  %Regression vector(s)
        switch modl.scale
        case 'mean'
          modl.ypred  = rescale(x*modl.reg,modl.meany);
        case 'auto'
          modl.ypred  = rescale(x*modl.reg,modl.meany,modl.stdy);
        otherwise
          modl.ypred  = x*modl.reg;
        end
        %Sample residuals Q
        if size(modl.loads,2)<min(size(x))
          resmat = x - modl.scores*modl.loads';
          if size(resmat,1) > size(resmat,2)
            covr = (resmat'*resmat)/(size(resmat,1)-1);
          else
            covr = (resmat*resmat')/(size(resmat,1)-1);
          end
          modl.res    = sum(resmat.^2,2);
          emod = svd(covr);
          emod = emod(1:length(emod)-m);
          modl.reseig = emod;
          modl.reslim = reslim(0,emod,95);
        else
          modl.res = zeros(m,1);
          modl.reslim = 0;
        end
        %T^2 and Limit
        ps          = 1./sqrt(diag(modl.scores'*modl.scores)/(modl.samps-1));
        modl.tsq    = modl.scores*diag(ps);
        if m>1
          modl.tsq  = sum((modl.tsq.^2)')';
        else
          modl.tsq  = modl.tsq.^2;
        end
        modl.tsqlim = tsqlim(mx,m,95);    %95% conf limit for T^2
        modl.lev    = diag(1./diag(modl.scores'*modl.scores));
        modl.lev    = diag(modl.scores*modl.lev*modl.scores'); %Leverage
        modl.yres   = modl.ypred-y;  %y in original units
        p           = ones(mx,1)-modl.lev;
        p           = p(:,ones(1,ny));
        ps          = sqrt(diag(modl.yres'*(modl.yres./(p.^2)))/(mx-1))';
        modl.yres   = modl.yres./(ps(ones(mx,1),:).*sqrt(p));
        set(e(5,1),'UserData',modl.yres)
        set(bb(12,1),'Enable','off')
      else                                %apply to test data
        switch lower(modl.name)
        case 'nip'
          xhat      = x;
          test.scores = zeros(mx,m);
          for ii=1:m
            test.scores(:,ii) = xhat*modl.wts(:,ii);
            xhat    = xhat-test.scores(:,ii)*modl.loads(:,ii)';
          end
          test.ypred  = x*modl.reg;
        case 'sim'
          test.scores = x*modl.wts(:,1:m);
          for ii=1:m
            test.scores(:,ii) = test.scores(:,ii)* ...
              norm(modl.scores(:,ii));
          end
          test.ypred  = x*modl.reg;
        case 'pcr'
          test.ypred  = x*modl.reg;
          test.scores = x*modl.loads;
        end
        test.date   = date;               %date test performed
        test.time   = clock;              %time test performed
        switch modl.scale
        case 'mean'
          test.ypred  = rescale(test.ypred,modl.meany);
        case 'auto'
          test.ypred  = rescale(test.ypred,modl.meany,modl.stdy);
        end
        %Sample residuals Q
        test.res    = (x - test.scores*modl.loads').^2;
        test.res    = sum(test.res')';
        %Sample T^2
        test.tsq    = 1./sqrt(diag(modl.scores'*modl.scores)/(modl.samps-1));
        test.tsq    = test.scores*diag(test.tsq);
        if m>1
          test.tsq  = sum((test.tsq.^2)')';
        else
          test.tsq  = test.tsq.^2;
        end
        set(bb(12,1),'Enable','on')
      end
      if strcmp(stat.data,'new')
        stat.data = 'test';
        stat.modl = 'loaded';
      end
      if strcmp(stat.data,'cal')
        stat.modl = 'calold';
      end
    end  
  case 'actssq'
    if strcmp(stat.modl,'loaded')
      n      = get(f(4,1),'UserData');
      set(e(3,1),'String',int2str(n))
      set(e(4,1),'Value',n)
    elseif ~strcmp(stat.data,'none')
      n      = get(e(4,1),'Value');
      set(e(3,1),'String',int2str(n))
      set(f(4,1),'UserData',n)
      stat.modl = 'calnew';
    end
  case 'actssq2'
    if strcmp(stat.modl,'loaded')
      n      = get(f(4,1),'UserData');
      set(e(3,1),'String',int2str(n))
      set(e(4,1),'Value',n)
    elseif ~strcmp(stat.data,'none')&~strcmp(stat.modl,'none')
      n      = str2num(get(e(3,1),'String'));
      n      = round(n);
      if (n<1)|(n>max(modl.ssq(:,1)))
        n    = 1;
      end
      set(e(4,1),'Value',n);
      set(e(3,1),'String',int2str(n))
      set(f(4,1),'UserData',n)
      stat.modl = 'calnew';
    end
  case 'showp'
    if get(e(8,1),'Value')
      set(p2,'Visible','on')
    else
      set(p2,'Visible','off')
    end
  case 'showp2'
    set(e(8,1),'Value',0)
    set(p2,'Visible','off')
  case 'printssqtable'
    ssqtable(modl,size(modl.loads,2));
  case 'maxlvs'
    s        = round(get(e2(1,1),'Value'));
    set(f2(1,1),'String',int2str(s))
    if strcmp(stat.modl,'calold')&s<=size(modl.loads,2)
      stat.modl  = 'calnew';
    elseif strcmp(stat.modl,'calnew')&s<=size(modl.loads,2)