Fisher线性判别
Fisher线性判别（Fisher Linear Discrimination，FLD），也称线性判别式分析(Linear Discriminant Analysis, LDA)。FLD是基于样本类别进行整体特征提取的有效方法。它在使用PCA方法进行降维的基础上考虑到训练样本的类间信息。FLD的基本原理就是找到一个最合适的投影轴,使各类样本在该轴上投影之间的距离尽可能远,而每一类内的样本的投影尽可能紧凑,从而使分类效果达到最佳,即在最大化类间距离的同时最小化类内距离。FLD方法在进行图像整体特征提取方面有着广泛的应用。
在应用统计方法解决模式识别问题时，经常会遇到所谓的“维数灾难”的问题，在低维空间里适用的方法在高维空间里可能完全不适用。因此压缩特征空间的维数有时是很重要的。Fisher方法实际上涉及维数压缩的问题。如果把多维特征空间的点投影到一条直线上，就能把特征空间压缩成一维，这个在数学上是很容易办到的。但是，在高维空间里很容易分开的样品，把它们投影到任意一根直线上，有可能不同类别的样品就混在一起，无法区分，如图1(a)所示投影到xl或x2轴无法区分。若把直线绕原点转动一下，就有可能找到一个方向，样品投影到这个方向的直线上，各类样品就能很好地分开，如图1(b)所示。因此直线方向的选择很重要。一般地，总能够找到一个最好的方向，使样品投影到这个方向的直线上很容易分开。如何找到这个最好的直线方向以及如何实现向最好方向投影的变换，这正是Fisher算法要解决的基本问题，这个投影变换恰是我们所寻求的解向量w*。
图1 Fisher线性判别示意图
样品训练集以及待测样品的特征总数目为n。为了找到最佳投影方向，需要计算出各类样品均值，样品类内离散度矩阵Si和总类间离散度矩阵Sw，样品类间离散度矩阵Sb，根据Fisher准则，找到最佳投影向量，将训练集内所有样品进行投影，投影到一维Y空间，由于Y空间是一维的，则需要求出Y空间的划分边界点，找到边界点后，就可以对待测样品进行一维Y空间的投影，判断它的投影点与分界点的关系，将其归类。具体方法如下。
/******************************************************************
* 函数名称：Fisher_2Classes(int Class0, int Class1)
* 函数类型：int
* 参数说明：Class0,Class1：0～9中的任意两个类别
* 函数功能：两类Fisher分类器,返回Class0，Class1中的一个
******************************************************************/
int Classification::Fisher_2Classes(int Class0, int Class1)
{
double Xmeans[2][25];//两类的均值
double S[2][25][25];//样品类内离散度矩阵
double Sw[25][25];//总类间离散度矩阵
double Sw_[25][25];//Sw的逆矩阵
double W[25];//解向量w*
double difXmeans[25];//均值差
double X[25];//未知样品
double m0,m1;//类样品均值
double y0;//阈值y0
int i,j,k;
for(i=0;i<2;i++)
for(j=0;j<25;j++)
Xmeans[i][j]=0;
int num0,num1; //两类样品的个数
//两类样品特征
double mode0[200][25],mode1[200][25];
//两类样品个数
num0=40;//pattern[Class0].number;
num1=40;//pattern[Class1].number;
for(i=0;i<num0;i++)
{
for(j=0;j<25;j++)
{
Xmeans[0][j]+=pattern[Class0].feature[i][j];
mode0[i][j]=pattern[Class0].feature[i][j];
}
}
for(i=0;i<num1;i++)
{
for(j=0;j<25;j++)
{
Xmeans[1][j]+=pattern[Class1].feature[i][j];
mode1[i][j]=pattern[Class1].feature[i][j];
}
}
//求得两个样品均值向量
for(i=0;i<25;i++)
{
Xmeans[0][i]/=(double)num0;
Xmeans[1][i]/=(double)num1;
}
//求两类样品类内离散度矩阵
for(i=0;i<25;i++)
for(j=0;j<25;j++)
{
double s0=0.0,s1=0.0;
for(k=0;k<num0;k++)
s0=s0+(mode0[k][i]-Xmeans[0][i])*(mode0[k][j]-Xmeans[0][j]);
s0=s0/(double)(num0-1);
S[0][i][j]=s0;//第一类
for(k=0;k<num1;k++)
s1=s1+(mode1[k][i]-Xmeans[1][i])*(mode1[k][j]-Xmeans[1][j]);
s1=s1/(double)(num1-1);
S[1][i][j]=s1;//第二类
}
//总类间离散度矩阵
for(i=0;i<25;i++)
for(j=0;j<25;j++)
{
Sw[i][j]=S[0][i][j]+S[1][i][j];
}
//Sw的逆矩阵
for(i=0;i<25;i++)
for(j=0;j<25;j++)
Sw_[i][j]=Sw[i][j];
double(*p)[25]=Sw_;
brinv(*p,25); //Sw的逆矩阵Sw_
//计算w* w*＝Sw_×(Xmeans0-Xmeans1)
for(i=0;i<25;i++)
difXmeans[i]=Xmeans[0][i]-Xmeans[1][i];
for(i=0;i<25;i++)
W[i]=0.0;
brmul(Sw_,difXmeans,25,W);//计算出W*
//各类样品均值
m0=0.0;
m1=0.0;
for(i=0;i<num0;i++)
{
m0+=brmul(W,mode0[i],25);
}
for(i=0;i<num1;i++)
{
m1+=brmul(W,mode1[i],25);
}
m0/=(double)num0;
m1/=(double)num1;
y0=(num0*m0+num1*m1)/(num0+num1);//阈值y0
//对于任意的手写数字X
for(i=0;i<25;i++)
X[i]=testsample[i];
double y;//X在w*上的投影点
y=brmul(W,X,25);
if (y>=y0)
return Class0;
else
return Class1;
}
/******************************************************************
* 函数名称：Fisher()
* 函数类型：int
* 函数功能：Fisher分类器,返回手写数字的类别
******************************************************************/
int Classification::Fisher()
{
int i,j,number,maxval,num[10];
for(i=0;i<10;i++)
num[i]=0;
for(i=0;i<10;i++)
for(j=0;j<i;j++)
num[Fisher_2Classes(i,j)]++;
maxval=num[0];
number=0;
for(i=1;i<10;i++)
{
if(num[i]>maxval)
{
maxval=num[i];
number=i;
}
}
return number;
}
/******************************************************************
*函数名称：brmul(double a[],double b[][25],int n,double c[])
*函数类型：void
*参数说明：a－双精度实型数组，存放A的元素。
* b－双精度实型数组，存放B的元素。
* n－整型变量，矩阵A的列数，也是矩阵B的行数。
* c－双精度实型数组，存放乘积矩阵C=AB的元素。
*函数功能：求矩阵A与B的乘积矩阵C=AB。
******************************************************************/
void brmul(double a[],double b[][25],int n,double c[])//矩阵乘法，c=a*b
{
for(int i=0;i<n;i++)
{
for(int j=0;j<n;j++)
c[i]+=a[j]*b[j][i];
}
return;
}
/******************************************************************
*函数名称：brinv(double a[],int n)
*函数类型：void
*参数说明：a--双精度实型数组，n--整型变量，方阵A的阶数
*函数功能：用全选主元Gauss-Jordan消去法求n阶实矩阵A的逆矩阵
******************************************************************/
void brinv(double a[],int n)
{
int *is,*js,i,j,k,l,u,v;
double d,p;
is=new int[n];
js=new int[n];
for (k=0; k<=n-1; k++)
{
d=0.0;
for (i=k; i<=n-1; i++)
for (j=k; j<=n-1; j++)
{
l=i*n+j; p=fabs(a[l]);
if (p>d)
{
d=p; is[k]=i; js[k]=j;
}
}
if (d+1.0==1.0)
{
free(is); free(js); printf("err**not inv\n");
return;
}
if (is[k]!=k)
for (j=0; j<=n-1; j++)
{
u=k*n+j; v=is[k]*n+j;
p=a[u]; a[u]=a[v]; a[v]=p;
}
if (js[k]!=k)
for (i=0; i<=n-1; i++)
{
u=i*n+k; v=i*n+js[k];
p=a[u]; a[u]=a[v]; a[v]=p;
}
l=k*n+k;
a[l]=1.0/a[l];
for (j=0; j<=n-1; j++)
if (j!=k)
{
u=k*n+j; a[u]=a[u]*a[l];
}
for (i=0; i<=n-1; i++)
if (i!=k)
for (j=0; j<=n-1; j++)
if (j!=k)
{
u=i*n+j;
a[u]=a[u]-a[i*n+k]*a[k*n+j];
}
for (i=0; i<=n-1; i++)
if (i!=k)
{
u=i*n+k; a[u]=-a[u]*a[l];
}
}
for (k=n-1; k>=0; k--)
{
if (js[k]!=k)
for (j=0; j<=n-1; j++)
{
u=k*n+j; v=js[k]*n+j;
p=a[u]; a[u]=a[v]; a[v]=p;
}
if (is[k]!=k)
for (i=0; i<=n-1; i++)
{
u=i*n+k; v=i*n+is[k];
p=a[u]; a[u]=a[v]; a[v]=p;
}
}
delete is;
delete js;
}