makebalancedset.m

有监督自组织映射-偏最小二乘算法(A supervised self-organising map–partial least squares algorithm),可以用语多变量数据的回归分析

function [Xtr,Ytr,Xtest,Ytest] = MakeBalancedSet(X,Y,PercTrain,MLKP,NDiv);
%
% reset random generator to a fixed sequence
% this yields reproducable training and test sets
if upper(MLKP.FixedRandomData) == 'Y'
    rand('state',MLKP.RandomInitData);
else
    rand('state',sum(100*clock));
end
%
% for MLZ in XY mode
if (nargin == 5)
    DivVar = 2;
else
    DivVar = 1;
end
%
% if necessary, created a binned version of the X matrix
if (upper(MLKP.BinnedData) == 'Y')
    RX=BinDataSet(X,MLKP.BinnedSize);
    clear X
    X=RX;
end
[Nobjects,NvarY]=size(Y);
Xtr=[];
Ytr=[];
Xtest=[];
Ytest=[];
%
% sort according to classtype and split in training and test sets
if upper(MLKP.ProblemType)=='CLS'
    for ivar=1:NvarY/DivVar
        indx=0;
        Xsort=[];
        Ysort=[];
        Xperm=[];
        Yperm=[];
        for iobj=1:Nobjects
            if (Y(iobj,ivar) == 1)
                indx=indx+1;
                Xsort(indx,:)=X(iobj,:);
                Ysort(indx,:)=Y(iobj,:);
            end
        end
        if (upper(MLKP.CreateDataSet)=='RANDOM')
            IndxSort=randperm(indx);
            Xperm=Xsort(IndxSort,:);
            Yperm=Ysort(IndxSort,:);
            Pos = min(max(1,floor(indx*PercTrain/100)),indx-1);
            Xtr=[Xtr; Xperm(1:Pos,:)];
            Ytr=[Ytr; Yperm(1:Pos,:)];
            Xtest=[Xtest; Xperm(Pos+1:indx,:)];
            Ytest=[Ytest; Yperm(Pos+1:indx,:)];
        elseif (upper(MLKP.CreateDataSet)=='DISDIS')
            Xperm2=[];
            Yperm2=[];
            Centroid=mean(Xsort);
            XDistances=dist(Xsort,Centroid');
            [DistSort,Isort]=sort(-XDistances);
            Xsort=Xsort(Isort,:);
            Ysort=Ysort(Isort,:);
            Partition=10-round(PercTrain/10);
            HalfPartMin=5-floor(Partition/2);
            HalfPartMax=5+Partition-floor(Partition/2);
            indx1=0;
            indx2=0;
            for iobj=1:indx
                imod=mod(iobj,10);
                if imod >= HalfPartMin & imod < HalfPartMax
                    indx2=indx2+1;
                    Xperm2(indx2,:)=Xsort(iobj,:);
                    Yperm2(indx2,:)=Ysort(iobj,:);
                else
                    indx1=indx1+1;
                    Xperm(indx1,:)=Xsort(iobj,:);
                    Yperm(indx1,:)=Ysort(iobj,:);
                end
            end
            Xtr=[Xtr; Xperm];
            Ytr=[Ytr; Yperm];
            Xtest=[Xtest; Xperm2];
            Ytest=[Ytest; Yperm2];
        elseif (upper(MLKP.CreateDataSet)=='KSTONE')
            Pos = min(max(1,floor(indx*PercTrain/100)),indx-1);
            [TrainLabel,TestLabel]=KennardStone(Xsort,Pos);
            Xtr=[Xtr; Xsort(TrainLabel,:)];
            Ytr=[Ytr; Ysort(TrainLabel,:)];
            Xtest=[Xtest; Xsort(TestLabel,:)];
            Ytest=[Ytest; Ysort(TestLabel,:)];
        end
    end
else
    if (upper(MLKP.CreateDataSet)=='RANDOM')
        IndxSort=randperm(Nobjects);
        Xperm=X(IndxSort,:);
        Yperm=Y(IndxSort,:);
        Pos = min(max(1,floor(Nobjects*PercTrain/100)),Nobjects-1);
        Xtr=[Xperm(1:Pos,:)];
        Ytr=[Yperm(1:Pos,:)];
        Xtest=[Xperm(Pos+1:Nobjects,:)];
        Ytest=[Yperm(Pos+1:Nobjects,:)];
    elseif (upper(MLKP.CreateDataSet)=='DISDIS')
        Centroid=mean(X);
        XDistances=dist(X,Centroid');
        [DistSort,Isort]=sort(-XDistances);
        Xsort=X(Isort,:);
        Ysort=Y(Isort,:);
        Partition=10-round(PercTrain/10);
        HalfPartMin=5-floor(Partition/2);
        HalfPartMax=5+Partition-floor(Partition/2);
        indx1=0;
        indx2=0;
        for iobj=1:Nobjects
            imod=mod(iobj,10);
            if imod >= HalfPartMin & imod < HalfPartMax
                indx2=indx2+1;
                Xtest(indx2,:)=Xsort(iobj,:);
                Ytest(indx2,:)=Ysort(iobj,:);
            else
                indx1=indx1+1;
                Xtr(indx1,:)=Xsort(iobj,:);
                Ytr(indx1,:)=Ysort(iobj,:);
            end
        end
    elseif (upper(MLKP.CreateDataSet)=='KSTONE')
        Pos = min(max(1,floor(Nobjects*PercTrain/100)),Nobjects-1);
        [TrainLabel,TestLabel]=KennardStone(X,Pos);
        Xtr=X(TrainLabel,:);
        Ytr=Y(TrainLabel,:);
        Xtest=X(TestLabel,:);
        Ytest=Y(TestLabel,:);
    end
end
%
% randomise training and test set
[NobjectsTrain,Nvar]=size(Xtr);
perm=randperm(NobjectsTrain);
Xtr=Xtr(perm,:);
Ytr=Ytr(perm,:);
[NobjectsTest,Nvar]=size(Xtest);
perm=randperm(NobjectsTest);
Xtest=Xtest(perm,:);
Ytest=Ytest(perm,:);
%
% reset random generator to an arbitrary starting point
rand('state',sum(100*clock));