LDA人脸识别地matlab程序Word格式.docx

LDA人脸识别地matlab程序Word格式.docx

《LDA人脸识别地matlab程序Word格式.docx》由会员分享，可在线阅读，更多相关《LDA人脸识别地matlab程序Word格式.docx（11页珍藏版）》请在冰豆网上搜索。

%whenRegu==1.Defaultvalueis0.1.

%ReguType-'

Ridge'

:

Tikhonovregularization

%'

Custom'

Userprovided

%regularizationmatrix

'

%regularizerR-（nFeaxnFea）regularization

%matrixwhichshouldbeprovided

%ifReguTypeis'

.nFeais

%thefeaturenumberofdata

%matrix

%Fisherface-1:

Fisherfaceapproach

%PCARatio=nSmp-nClass

0

%PCARatio-Thepercentageofprincipal

%componentkeptinthePCA

%step.Thepercentageis

%calculatedbasedonthe

%eigenvalue.Defaultis1

%（100%,allthenon-zero

%eigenvalueswillbekept.

%IfPCARatio>

1,thePCAstep

%willkeepexactlyPCARatioprinciple

%components（doesnotexceedthe

%exactnumberofnon-zerocomponents）.

%Output:

%eigvector-Eachcolumnisanembeddingfunction,foranew

%datapoint（rowvector）x,y=x*eigvector

%willbetheembeddingresultofx.

%eigvalue-ThesortedeigvalueofLDAeigen-problem.

%elapse-Timespentondifferentsteps

%Examples:

%fea=rand（50,70）;

%gnd=[ones（10,1）;

ones（15,1）*2;

ones（10,1）*3;

ones（15,1）*4];

%options=[];

%options.Fisherface=1;

%[eigvector,eigvalue]=LDA（gnd,options,fea）;

%Y=fea*eigvector;

%SeealsoLPP,constructW,LGE

%Reference:

%P.N.Belhumeur,J.P.Hespanha,andD.J.Kriegman,揈igenfaces

%vs.fisherfaces:

recognitionusingclassspecificlinear

%projection,�IEEETransactionsonPatternAnalysisandMachine

%Intelligence,vol.19,no.7,pp.711-720,July1997.

%DengCai,XiaofeiHe,YuxiaoHu,JiaweiHan,andThomasHuang,

%"

LearningaSpatiallySmoothSubspaceforFaceRecognition"

CVPR'

2007

%DengCai,XiaofeiHe,JiaweiHan,"

SRDA:

AnEfficientAlgorithmfor

%LargeScaleDiscriminantAnalysis"

IEEETransactionsonKnowledgeand

%DataEngineering,2007.

%version2.1--June/2007

%version2.0--May/2007

%version1.1--Feb/2006

%version1.0--April/2004

%WrittenbyDengCai（dengcai2ATcs.uiuc.edu）

if~exist（'

data'

'

var'

）

globaldata;

end

if（~exist（'

options'

））

options=[];

if~isfield（options,'

Regu'

）|~options.Regu

bPCA=1;

if~isfield（options,'

PCARatio'

options.PCARatio=1;

end

else

bPCA=0;

ReguType'

options.ReguType='

;

ReguAlpha'

options.ReguAlpha=0.1;

tmp_T=cputime;

%======Initialization

[nSmp,nFea]=size（data）;

iflength（gnd）~=nSmp

error（'

gndanddatamismatch!

'

）;

classLabel=unique（gnd）;

nClass=length（classLabel）;

Dim=nClass-1;

ifbPCA&

isfield（options,'

Fisherface'

）&

options.Fisherface

options.PCARatio=nSmp-nClass;

ifissparse（data）

data=full（data）;

sampleMean=mean（data,1）;

data=（data-repmat（sampleMean,nSmp,1））;

bChol=0;

（nSmp>

nFea+1）&

（options.PCARatio>

=1）

DPrime=data'

*data;

DPrime=max（DPrime,DPrime'

[R,p]=chol（DPrime）;

ifp==0

bChol=1;

%======================================

%SVD

ifbPCA

ifnSmp>

nFea

ddata=data'

ddata=max（ddata,ddata'

[eigvector_PCA,eigvalue_PCA]=eig（ddata）;

eigvalue_PCA=diag（eigvalue_PCA）;

clearddata;

maxEigValue=max（abs（eigvalue_PCA））;

eigIdx=find（eigvalue_PCA/maxEigValue<

1e-12）;

eigvalue_PCA（eigIdx）=[];

eigvector_PCA（:

eigIdx）=[];

[junk,index]=sort（-eigvalue_PCA）;

eigvalue_PCA=eigvalue_PCA（index）;

eigvector_PCA=eigvector_PCA（:

index）;

%=======================================

ifoptions.PCARatio>

1

idx=options.PCARatio;

ifidx<

length（eigvalue_PCA）

eigvalue_PCA=eigvalue_PCA（1:

idx）;

1:

elseifoptions.PCARatio<

sumEig=sum（eigvalue_PCA）;

sumEig=sumEig*options.PCARatio;

sumNow=0;

foridx=1:

length（eigvalue_PCA）

sumNow=sumNow+eigvalue_PCA（idx）;

ifsumNow>

=sumEig

break;

eigvalue_PCA=eigvalue_PCA.^-.5;

data=（data*eigvector_PCA）.*repmat（eigvalue_PCA'

nSmp,1）;

else

ddata=data*data'

[eigvector,eigvalue_PCA]=eig（ddata）;

maxEigValue=max（eigvalue_PCA）;

eigvector（:

eigvector=eigvector（:

eigvector_PCA=（data'

*eigvector）.*repmat（eigvalue_PCA'

nFea,1）;

data=eigvector;

cleareigvector;

if~bChol

%options.ReguAlpha=nSmp*options.ReguAlpha;

switchlower（options.ReguType）

case{lower（'

）}

fori=1:

size（DPrime,1）

DPrime（i,i）=DPrime（i,i）+options.ReguAlpha;

Tensor'

DPrime=DPrime+options.ReguAlpha*options.regularizerR;

otherwise

ReguTypedoesnotexist!

Hb=zeros（nClass,nFea）;

fori=1:

nClass,

index=find（gnd==classLabel（i））;

classMean=mean（data（index,:

）,1）;

Hb（i,:

）=sqrt（length（index））*classMean;

elapse.timeW=0;

elapse.timePCA=cputime-tmp_T;

ifbPCA

[dumpVec,eigvalue,eigvector]=svd（Hb,'

econ'

eigvalue=diag（eigvalue）;

eigIdx=find（eigvalue<

1e-3）;

eigvalue（eigIdx）=[];

eigvalue=eigvalue.^2;

eigvector=eigvector_PCA*（repmat（eigvalue_PCA,1,length（eigvalue））.*eigvector）;

WPrime=Hb'

*Hb;

WPrime=max（WPrime,WPrime'

dimMatrix=size（WPrime,2）;

ifDim>

dimMatrix

Dim=dimMatrix;

ifisfield（options,'

bEigs'

ifoptions.bEigs

bEigs=1;

bEigs=0;

if（dimMatrix>

1000&

Dim<

dimMatrix/10）|（dimMatrix>

500&

dimMatrix/20）|（dimMatrix>

250&

dimMatrix/30）

ifbEigs

%disp（'

useeigstospeedup!

option=struct（'

disp'

0）;

ifbChol

option.cholB=1;

[eigvector,eigvalue]=eigs（WPrime,R,Dim,'

la'

option）;

[eigvector,eigvalue]=eigs（WPrime,DPrime,Dim,'

[eigvector,eigvalue]=eig（WPrime,DPrime）;

[junk,index]=sort（-eigvalue）;

eigvalue=eigvalue（index）;

index）;

ifDim<

size（eigvector,2）

1:

Dim）;

eigvalue=eigvalue（1:

size（eigvector,2）

i）=eigvector（:

i）./norm（eigvector（:

i））;

elapse.timeMethod=cputime-tmp_T;

elapse.timeAll=elapse.timePCA+elapse.timeMethod;