lssvmbayforward0.m

The goal of SPID is to provide the user with tools capable to simulate, preprocess, process and clas

function [forList, ptrnNew, ptrnRest, vpredRest, vpredAdd, nAdd]=lssvmBayForward(ptrnInit, ttrn, ptrnWait, vpredWait, L3Init, nstep, saveUniL3, displ)
% function [forList, ptrnNew, ptrnRest, vpredRest, vpredAdd, nAdd]=lssvmBayForward(ptrnInit, ttrn, ptrnWait, vpredWait, L3Init, nstep, saveUniL3, displ)

if nargin < 4,
   disp('No enough Inputs'),
   help lssvmBayForward,
   return,
end,
if nargin < 5,
   L3Init = inf;
end,
if nargin < 6,
   nstep = size(ptrnWait,2);
end,

if nargin < 7,
   saveUniL3=0;
end,

if nargin < 8,
    displ=1;
end,

global nlsig kernelType,
if kernelType=='rbf',
    knl=1; else knl=2;
end,

%nlsig=3; % total number of levels needed to refine the Sigmas.
numSteps=2; % # refined points added to the Sigmas to the left/right centered at a point.

disp(['#Initial inputs : ', num2str(size(ptrnInit,2)), ' x ', num2str(length(ttrn))]),
disp(['#Waiting inputs : ', num2str(size(ptrnWait,2)), ' x ', num2str(length(ptrnWait))]),

L3star=L3Init; L3stars=[]; 
forList=struct('type', '+','name', 'null', 'L3', L3Init, 'sigOpt', 0, 'gamOpt', 0, 'neffPar', 0);
nvWait=size(ptrnWait, 2);
idxAdd=[]; waitList=[1: nvWait]; nAdd = 0; N_inputs= size(ptrnInit, 2);
disp('------------------------------------------------'),
disp('--- Lssvm Bayesian Input Selection: forward ----'),
disp('------------------------------------------------'),

for step=1:nstep,
   waitList = setdiff(waitList, idxAdd);
   if isempty(waitList),
       disp('No more waiting variable!'),
       break,
   end,
   N_inputs=N_inputs+1;

   %Sigma = sqrt(N_inputs/8)*[0.5 1 1.5 2 3 4 5 6 8 10];
%   Sigma = sqrt(N_inputs/8)*[1 2 3 4 5 6];
   Sigmas = [];
   
   nst=length(waitList);
   iAdd=0;
   L3=[]; sig=zeros(1,nst); gamma=zeros(1,nst);
   for st=1:nst,
       if displ, fprintf('.%g', st),
       elseif mod(st, 100)==0,
           fprintf('.%g', st),
       end,
       
       Xtrain = [ptrnInit, ptrnWait(:,[idxAdd, waitList(st)])]; Ytrain = ttrn;
       if kernelType=='rbf',
           Sigma0 = sqrt(N_inputs)*[0.1 1 2 3 5];
       else
           if kernelType=='lin',
           Sigma0 = [1]; nlsig=1;
           elseif kernelType=='pol',
               Sigma0=[1:4]; nlsig=1;
           end
       end,
       [sig(st), gamma(st), L3(st), numEffPar(st)]=...
           optSigGamLssvmBay(Xtrain, Ytrain, Sigma0, nlsig,0,knl); 
   end, %for st   
   fprintf('\n'), 
   if saveUniL3 & step==1,
      save MATL3gamsig1 L3 sig gamma numEffPar, disp('Ok!!'),
   end,

   
   % To check if to add the variable or not!
   if min(L3)<L3star,
      [L3star, iopt] = min(L3);
	  sig_opt = sig(iopt);
  	  gam_opt = gamma(iopt);
      neffPar = numEffPar(iopt); 
      nAdd = nAdd + 1;
      iAdd=waitList(iopt);
      va=vpredWait{iAdd};
      
      forList(step).type ='+';
      forList(step).name = va;
      forList(step).L3=L3star;
      forList(step).sigOpt=sig_opt;
      forList(step).gamOpt=gam_opt;
      forList(step).neffPar=neffPar;
      idxAdd=[idxAdd, iAdd];
      
     disp(['For ', num2str(N_inputs), ' inputs:']),
	 disp(['  Optimal Sigma : ', num2str(sig_opt), ' ; Optimal gamma : ', num2str(gam_opt)]),
     disp(['  current L3    : ', num2str(L3star), ' ; #effect Param : ', num2str(neffPar)]),
     disp(['  ======= ', num2str(nAdd), '. variable added: ', va]),
      
    else
%      save MATL3gamsig_rbf_end L3 sig gamma numEffPar, disp('Ok!!'),
      disp('  ======= No more variable can be added!'),
      break,
    end,

end, % For step 

disp('Forward selection summary: '),

for fi=1:size(forList,2),
   disp([num2str(fi), '. ', forList(fi).name, ' : ', num2str(forList(fi).L3)]),
end,

ptrnNew=[ptrnInit, ptrnWait(:,idxAdd)];
idxRest=setdiff([1:nvWait], idxAdd);
ptrnRest=ptrnWait(:,idxRest);

vpredRest={};
for i=1:nvWait-nAdd,
    vpredRest{i}=vpredWait{idxRest(i)}; 
end,

vpredAdd={};
for i=1:nAdd,
    vpredAdd{i}=vpredWait{idxAdd(i)};
end,

return,