精华内容
下载资源
问答
  • fisher算法

    2014-10-22 22:05:13
    课堂上作业关于简易fisher算法的简单程序,对于初学者和你好的借鉴
  • Fisher算法

    2011-11-21 14:07:40
    矩阵实现 矩阵运算算法 模式识别 Fisher分类算法
  • 为了解决分类问题中的高维而导致的维数灾难问题,提出了Fisher算法和基于核的Fisher算法的分类器设计方法
  • fisher算法matlab实现

    2019-02-28 12:26:44
    实现fisher算法,并对两个二维正态分布随机序列 进行训练,进而可在屏幕上任意取点,程序可输出属于第一类 还是第二类
  • fisher算法 matlab

    2013-11-05 20:37:44
    fisher算法基于matlab 的实现,线性判别
  • OFDM自适应算法对比_将chow算法_hudges算法_fisher算法的各种信道条件统一化的实验
  • Fisher算法python实现含训练集和测试集,Fisher算法也叫Fisher判别分析,或线性判别分析(LDA)
  • fisher算法的matlab实现

    2017-06-25 18:31:09
    fisher算法的matlab实现
  • 通过向量来定位,用二维数组来确定,实现FISHER算法
  • fisher算法及其matlab实现.doc
  • MATLAB源码集锦-基于Fisher算法的分类程序
  • 一篇很好的关于人脸识别的Gabor和Fisher算法实现,是一片ieee的外文文献。
  • 基于Fisher算法的分类程序matlab代码
  • Fisher算法及其MATLAB实现

    千次阅读 2020-05-24 14:21:52
    Fisher算法 Fisher算法是对线性可分问题的非迭代解法,其将高维特征空间中的样本投影到一条直线上,实现从高维到一维的数据压缩。如果在投影后的直线上训练样本具有很好的分布,则可以通过简单操作实现对输入样本的...

    Fisher算法

    Fisher算法是对线性可分问题的非迭代解法,其将高维特征空间中的样本投影到一条直线上,实现从高维到一维的数据压缩。如果在投影后的直线上训练样本具有很好的分布,则可以通过简单操作实现对输入样本的分类
    X = { X 1 , X 2 , . . . , X N } = { X 1 , X 2 , . . . , X n i ∈ ω i X n i + 1 , X n i + 2 , . . . , X N ∈ ω j \mathcal{X}=\{X_1,X_2,...,X_N\}=\left\{ \begin{aligned} X_1,X_2,...,X_{n_i} \in \omega_i \\ X_{n_i+1},X_{n_i+2},...,X_N \in \omega_j \end{aligned} \right. X={X1,X2,...,XN}={X1,X2,...,XniωiXni+1,Xni+2,...,XNωj
    X k , k = 1 , 2 , . . . , N X_k,k=1,2,...,N Xk,k=1,2,...,N W W W方向上的投影为
    y k = W T X k , k = 1 , 2 , . . . , N y_k=W^TX_k,k=1,2,...,N yk=WTXk,k=1,2,...,N
    为获取最佳投影方向,我们引入准则函数。在此之前,先介绍两个概念:

    • 类间距:不同类别样本均值的差别应尽可能大
    • 类内距:相同类别样本均值的方差应尽可能小

    m y l = 1 n l ∑ y k ∈ ω l W T X k = W T ( 1 n l ∑ X k ∈ ω l X k ) = W T m x l , l = i , j m_y^l=\frac{1}{n_l}\sum\limits_{y_k \in \omega_l}W^TX_k=W^T(\frac{1}{n_l}\sum\limits_{X_k \in \omega_l}X_k)=W^Tm_x^l, l=i,j myl=nl1ykωlWTXk=WT(nl1XkωlXk)=WTmxl,l=i,j
    投影后两个类别的类间离散度为:
    ∣ m y i − m y j ∣ 2 = ∥ W T m x i − W T m x j ∥ 2 = ∥ W T ( m x i − m x j ) ∥ 2 = W T ( m x i − m x j ) [ W T ( m x i − m x j ) ] T = W T ( m x i − m x j ) ( m x i − m x k ) T W = W T S b W \left|m_y^i-m_y^j \right|^2=\left\|W^Tm_x^i-W^Tm_x^j \right\|^2=\left\|W^T(m_x^i-m_x^j)\right\|^2\\ =W^T(m_x^i-m_x^j)[W^T(m_x^i-m_x^j)]^T=W^T(m_x^i-m_x^j)(m_x^i-m_x^k)^TW=W^TS_bW myimyj2=WTmxiWTmxj2=WT(mximxj)2=WT(mximxj)[WT(mximxj)]T=WT(mximxj)(mximxk)TW=WTSbW
    其中 S b S_b Sb为投影前两个类别的类间离散度矩阵

    投影后两个类别的类内离散度为:
    S l ˉ 2 = ∑ y k ∈ ω l ( y k − m y l ) 2 = ∑ X k ∈ ω l ( X T X k − W T m x l ) 2 , l = i , j S i ˉ 2 + S j ˉ 2 = ∑ X k ∈ ω i ( W T X k − W T m x i ) 2 + ∑ X k ∈ ω j ( W T X k − W T m x j ) 2 = W T [ ∑ X k ∈ ω i ( X k − m x i ) ( X k − m x i ) T + ∑ X k ∈ ω j ( X k − m x j ) ( X k − m x j ) T ] W = W T S w W \bar{S_l}^2=\sum\limits_{y_k \in\omega_l}(y_k-m_y^l)^2=\sum\limits_{X_k \in\omega_l}(X^TX_k-W^Tm_x^l)^2,l=i,j \\ \bar{S_i}^2+\bar{S_j}^2=\sum\limits_{X_k \in\omega_i}(W^TX_k-W^Tm_x^i)^2+\sum\limits_{X_k \in\omega_j}(W^TX_k-W^Tm_x^j)^2 \\ =W^T[\sum\limits_{X_k \in\omega_i}(X_k-m_x^i)(X_k-m_x^i)^T+\sum\limits_{X_k \in\omega_j}(X_k-m_x^j)(X_k-m_x^j)^T]W=W^TS_wW Slˉ2=ykωl(ykmyl)2=Xkωl(XTXkWTmxl)2,l=i,jSiˉ2+Sjˉ2=Xkωi(WTXkWTmxi)2+Xkωj(WTXkWTmxj)2=WT[Xkωi(Xkmxi)(Xkmxi)T+Xkωj(Xkmxj)(Xkmxj)T]W=WTSwW
    其中 S w S_w Sw为投影前样本的类内离散度矩阵

    引入Fisher准则函数
    J F ( W ) = ∣ m y i − m y j ∣ 2 S i ˉ 2 + S j ˉ 2 = W T S b W W T S w W J_F(W)=\frac{\left|m_y^i-m_y^j \right|^2}{\bar{S_i}^2+\bar{S_j}^2}=\frac{W^TS_bW}{W^TS_wW} JF(W)=Siˉ2+Sjˉ2myimyj2=WTSwWWTSbW
    构造拉格朗日函数使得 J F ( W ) J_F(W) JF(W)取极值:
    L ( W , λ ) = W T S b W − λ ( W T S w W − c ) L(W,\lambda)=W^TS_bW-\lambda(W^TS_wW-c) L(W,λ)=WTSbWλ(WTSwWc)
    对其求解,有:
    ∂ ∂ W L ( W , λ ) = 2 ( S b W − λ S w W ) = 0 ∂ ∂ λ L ( W , λ ) = W T S w W − c = 0 S b W ∗ = λ S w W ∗ S b W ∗ = [ ( m x i − m x j ) ( m x i − m x j ) T ] W ∗ = ( m x i − m x j ) [ ( m x i − m x j ) T W ∗ ] \frac{\partial}{\partial W} L(W,\lambda)=2(S_bW-\lambda S_wW)=0 \\ \frac{\partial}{\partial \lambda}L(W,\lambda)=W^TS_wW-c=0\\ S_bW^*=\lambda S_wW^*\\ S_bW^*=[(m_x^i-m_x^j)(m_x^i-m_x^j)^T]W^*=(m_x^i-m_x^j)[(m_x^i-m_x^j)^TW^*] WL(W,λ)=2(SbWλSwW)=0λL(W,λ)=WTSwWc=0SbW=λSwWSbW=[(mximxj)(mximxj)T]W=(mximxj)[(mximxj)TW]
    [ ( m x i − m x j ) T W ∗ ] [(m_x^i-m_x^j)^TW^*] [(mximxj)TW] r r r,则
    { S b W ∗ = λ S w W ∗ S b W ∗ = r ( m x i − m x j ) \left\{ \begin{aligned} S_bW^*=\lambda S_wW^*\\ S_bW^*=r(m_x^i-m_x^j) \end{aligned} \right. {SbW=λSwWSbW=r(mximxj)
    当样本数足够多时, S w S_w Sw一般是非奇异的
    W ∗ = r λ S w − 1 ( m x i − m x j ) W^*=\frac{r}{\lambda}S_w^{-1}(m_x^i-m_x^j) W=λrSw1(mximxj)
    进一步可以简化为 W ∗ = S w − 1 ( m x i − m x j ) W^*=S_w^{-1}(m_x^i-m_x^j) W=Sw1(mximxj)

    MATLAB实现

    function w=fisher(x1,x2) %输入的x为行向量
    size1=size(x1);
    size2=size(x2);
    
    
    sw=[0,0;0,0];
    sw_1=[0,0;0,0];
    sw_2=[0,0;0,0];
    for i=1:size1(1)
        m1(i)=mean(x1(:,i));
    end
    x1=x1';
    m1=m1'
    for j=1:size2(1)
        m2(j)=mean(x2(:,j));
    end
    x2=x2';
    m2=m2'
    
    sw=(x1(:,1)-m1)*(x1(:,1)-m1)'+(x1(:,2)-m1)*(x1(:,2)-m1)'+(x2(:,1)-m2)*(x2(:,1)-m2)'+(x2(:,2)-m2)*(x2(:,2)-m2)'
    sw_inv=inv(sw);
    w=sw_inv*(m1-m2);
    end
    
    展开全文
  • 用matlab实现模式识别中的Fisher算法
  • Fisher算法+两类问题

    千次阅读 2019-10-23 13:16:54
    文章目录一、Fisher算法二、蠓的分类问题:三、代码实现: 一、Fisher算法 二、蠓的分类问题: 两种蠓Af和Apf已由生物学家根据它们的触角和翼长加以区分(Af是能传播花粉的益虫,Apf是会传播疾病的害虫),两个矩阵...



    一、Fisher算法

    在这里插入图片描述

    二、蠓的分类问题:

    两种蠓AfApf已由生物学家根据它们的触角翼长加以区分(Af是能传播花粉的益虫,Apf是会传播疾病的害虫),两个矩阵中分别给出了6只Apf 和9只Af蠓的触角长(对应于矩阵的第1列)和翼长(对应于矩阵的第2列)的数据(See next slide)。根据触角长和翼长这两个特征来识别一个样本是Af还是Apf是重要的。

    (1)试给出该问题的Fisher分类器;

    (2)有三个待识别的模式样本,它们分别是(1.24,1.80),(1.28,1.84),( 1.40,2.04),试问这三个样本属于哪一种蠓。

    数据集:

    APF = np.array([
        [1.14,1.78],[1.18,1.96],
        [1.20,1.86],[1.26,2.00],
        [1.30,2.00],[1.28,1.96]
    ])
    
    AF = np.array([
        [1.24,1.72],[1.36,1.74],
        [1.38,1.64],[1.38,1.82],
        [1.38,1.90],[1.40,1.70],
        [1.48,1.82],[1.54,2.08],
        [1.56,1.78]
    ])
    

    三、代码实现:

    Fisher算法关键在于求出权向量W_和阈值W*,然后求出待测数据的映射y_test,最后与W*阈值作比较。

    import numpy as np
    
    
    APF = np.array([
        [1.14,1.78],[1.18,1.96],
        [1.20,1.86],[1.26,2.00],
        [1.30,2.00],[1.28,1.96]
    ])
    
    AF = np.array([
        [1.24,1.72],[1.36,1.74],
        [1.38,1.64],[1.38,1.82],
        [1.38,1.90],[1.40,1.70],
        [1.48,1.82],[1.54,2.08],
        [1.56,1.78]
    ])
    
    #获取样本均值
    def getAvg(x):
        return np.mean(x, axis=0)
    
    #求两类样本类内离散度矩阵Si
    def getSi(x, x_mean):
        x_mean = x_mean.reshape(x.shape[1],1)
        Si = np.zeros((x.shape[1],x.shape[1]))
        for xi in x:
            temp_xi = xi.copy().reshape(x.shape[1],1)
            temp = (temp_xi-x_mean)
            Si = Si + np.dot(temp, temp.T)
        return Si
    
    # 求权向量W_
    def getW(x1_mean,x2_mean,Sw):
        return np.dot(np.linalg.inv(Sw),(x1_mean-x2_mean))
    
    # 获取分类阈值w0和权向量W_
    def get_w0(x1, x2):
        x1_mean = getAvg(x1)
        x2_mean = getAvg(x2)
        S1 = getSi(APF, x1_mean)
        S2 = getSi(AF, x2_mean)
        Sw = S1+S2
        W_ = getW(x1_mean,x2_mean,Sw)
    
        #获取投影点
        y1 = np.dot(x1, W_)
        y2 = np.dot(x2, W_)
    
        #求各类样本均值yi_mean
        y1_mean = np.mean(y1)
        y2_mean = np.mean(y2)
    
        #选取分类阈值w0
        w0 = (y1_mean + y2_mean) / 2
    
        return w0, W_
    
    
    def Fisher(x1, x1_label, x2, x2_label, x_test):
        w0, W_ = get_w0(x1,x2)
        y_test = np.dot(x_test, W_)
        if y_test > w0:
            print('测试样本属于', x1_label)
        elif y_test <w0:
            print('测试样本属于',x2_label)
        else:
            print('测试样本可能属于%s,也可嫩属于%s'%x1_label%x2_label)
    
    
    x_tests = np.array([
        [1.24,1.80],[1.28,1.84],[1.40,2.04]
    ])
    
    i = 1
    for x_test in x_tests:
        print('第%d个'%i,end='')
        i += 1
        Fisher(APF,'蠓APF',AF,'蠓AF',x_test)
    

    预测结果如下:

    第1个测试样本属于 蠓APF
    第2个测试样本属于 蠓APF
    第3个测试样本属于 蠓APF
    
    展开全文
  • fisher算法matlab源程序

    2009-04-28 22:35:36
    这是本人参考张润楚编著的《多元统计分析》中fisher算法编写的matlab源程序,并且使用《多元统计分析》中fisher算法这一章节的例子进行检验,本人编写的算法与书本例子的结果相同。相信算法编写应该是对的。 压缩包...
  • fisher算法的实现matlab

    2014-04-10 22:08:56
    使用matlab对fisher算法进行了实现,对肥胖分类进行了划分,def loadLpaData(filename): f = open(filename,'r') data = {} for i in f.readlines(): order,ship = i.split()[0],i.split()[1] ships = ship....
  • 用C++实现的Fisher算法

    2010-05-09 10:22:05
    用C++实现的Fisher算法,我的毕设希望有用!
  • 模式识别导论大作业(k均值算法,感知器算法fisher算法,贝叶斯决策,特征提取)

     

     

     

    模式识别导论大作业


    一、      K均值聚类

    1.      功能描述:

    利用K-均值算法将150个模式样本分成3类别。分别计算最后算法所用的迭代次数,最终聚类中心以及每个类别中对应模式样本的序号。

    2.      带注释的源代码

    #include "stdio.h"

    #include "math.h"

    typedef struct mydata{

        float data[4];   //保存原始数据

        int index;

    }MyData;

    MyData myData[150];

    float classdata[3][150][4];

    int saveindex[3][150];  //保存下表

    float center[3][4];  //保存三个聚类中心

    float newcenter[3][4];//保存三个新的聚类中心

    int findMinCenter(float*temp){//找到当前数据的类别

        float dis[3]={0,0,0};

        float min = 100000;

        int returnk=0;

        for(int k=0;k<3;k++){

            float mytemp = 0;

            for(int m=0;m<4;m++)

                mytemp += (temp[m]-center[k][m])*(temp[m]-center[k][m]);

            dis[k] = sqrt(mytemp);

            //printf("%f\n",dis[k]);

            if(dis[k]<min){

                min = dis[k];

                returnk = k;

            }}  return returnk;

    }

    void counterNewCenter(floattempdata[][4],int len,int num){

        float temp[4] = {0,0,0,0}; //计算新的聚类中心方法

       

        for(int j=0;j<len;j++){

            for(int i=0;i<4;i++){

                temp[i] += tempdata[j][i];

            }   }

        for(int k=0;k<4;k++){

            newcenter[num][k] = temp[k]/len;

            printf("k = %f\n",newcenter[num][k]);

    }}

    int main(){

        int k=0;

        int kt[3] = {0,0,0};

        int i=0,u=0;

        FILE *fp;

        if ((fp = fopen("D:\\Iris.txt", "r")) ==NULL){  //打开文件

            printf("打开文件失败\n");

            return 0;

        }   float numtemp;

        while (!feof(fp)){     //读取数据

            fscanf(fp, "%f", &numtemp);

            myData[u].data[i++] = numtemp;

            if(i==4){

                u++;

                i=0;}   }

        fclose(fp);//关闭文件 

        for(k=0;k<4;k++){

            center[0][k] = myData[0].data[k];

            center[1][k] = myData[1].data[k];

            center[2][k] = myData[2].data[k];

        }//设置初始聚类中心

        int s=0;int num = 0;i=0;//聚类所用的迭代次数

        while(i<150){

            i++;

            k = findMinCenter(myData[i].data);

            //printf("k = %d\n",k);

            saveindex[k][kt[k]] = i;

            for(s=0;s<4;s++){

                classdata[k][kt[k]][s] = myData[i].data[s];}//每次将数据分到不同的类中

            kt[k]++;if (i == 150){

                printf("******************");

                for (int m = 0; m<3; m++)//计算新的聚类中心

                    counterNewCenter(classdata[m],kt[m],m);

                bool flag = true;//标示前后聚类中心是否相等的布尔类型

                for(int n=0;n<3;n++){

                    for(int t=0;t<4;t++){

                       if(newcenter[n][t] != center[n][t]){

                           flag = false;   break;}//if

                       if(!flag)   break;}//for   

                }//for

                if(!flag){  i = 0;num++; //如果前后两次的聚类中心不相等,则继续分类

                    for(int y=0;y<3;y++){

                       kt[y] = 0;

                       for(int w=0;w<4;w++)

                           center[y][w] = newcenter[y][w];//构建新的聚类中心

                       }//for

                }//if(!flag)

            }//if (i == 150)

                }//while

        printf("%d\n",num); //输出聚类所用的迭代次数

        if ((fp = fopen("D:\\result.txt", "wr")) ==NULL){  //创建result.txt文件

            printf("创建文件失败\n");

            return 0;   }

        for(i=0;i<3;i++){

            for(u=0;u<kt[i];u++){

                printf("%d  ",saveindex[i][u]);//将3组数据的下标写入文件保存

                fprintf(fp,"%d ",saveindex[i][u]);    }

            fprintf(fp,"\n\n\n");

        }fclose(fp);

        return 0;

    }

     

    3.      分类结果

    聚类所用的迭代次数: 11 

    第一组

    聚类中心 ( 5.004082  , 3.426531 , 1.463265  , 0.246939 )

    模式样本序号:1  2 3  4  5 6  7  8 9  10  11 12  13  14 15  16  17 18  19  20 21  22  23 24  25  26 27  28  29 30  31  32 33  34  35 36  37  38 39  40  41 42  43  44 45  46  47 48  49  50

     

    第二组:

    聚类中心 (5.883606  , 2.740984 , 4.409837 , 1.434426 )

    模式样本序号:52  54 55  56  57 58  59  60 61  62  63 64  65  66 67  68  69 70  71  72 73  74  75 76  77  79 80  81  82 83  84  85 86  87  88 89  90  91 92  93  94 95  96  97 98  99  100 102  107  114 115  120  122 124  127  128 134  139  143 147  150

     

    第三组:

    聚类中心 (6.853845    3.076923   5.715384    2.053846 )

    模式样本序号:51  53 78  101  103 104  105  106 108  109  110 111  112  113 116  117  118 119  121  123 125  126  129 130  131  132 133  135  136 137  138  140 141  142  144 145  146  148 149

     

    4.      算法分析

    文件中共有150个模式样本,要求分成3个模式类别,具体步骤如下:

    1.  读取文件中数据,由于样本维数为4。所以建立一个二维组用fscanf格式化读取文件中的样本数据。

    2.  选取3个初始样本中心,这里我选择的是样本前三个数据作为初始样本中。用center数据存储。

    3.  建立while循环,循环内依次将样本数据按照最短距离原则分类到3个聚类中心中的某一个。这里我用findMinCenter()方法返回当前数据到哪个聚类中心最近的序号。除此之外,用saveindex数组分别记录每个聚类中心中所包含模式样本的序号,方便最后将结果输出。

    4.  用counterNewCenter()计算当前类别的新的聚类中心。设置布尔类型的标识flag,初始为true。将3个新的聚类中心,分别和3个原始聚类中心相比较,如有有一个不相同,则设置flag为false,置样本索引i=0,继续循环。否则跳出循环。得到分类结果。

     

     

     

     

    二、      线性分类器设计(20分)

    以第一题的分类结果作为样本集,首先选取训练集与测试集(训练集大概是整体样本的2/3),请分别给出三个类别的训练集与测试集包含的样本编号:

    第一类训练集样本编号(样本个数26个): 51  53  78 101  103  104 105  106  108 109  110  111 112  113  116 117  118  119 121  123  125 126  129  130 131  132

    第二类训练集样本编号(样本个数40个): 52 54  55  56 57  58  59 60  61  62 63  64  65 66  67  68 69  70  71 72  73  74 75  76  77 79  80  81 82  83  84 85  86  87 88  89  90 91  92  93

    第三类训练集样本编号(样本个数33个): 1  2  3 4  5  6  7  8 9  10  11 12  13  14 15  16  17 18  19  20 21  22  23 24  25  26 27  28  29 30  31  32  33

    第一类测试集样本编号: 133  135 136  137  138 140  141  142 144  145  146 148  149

    第二类测试集样本编号: 94  95 96  97  98 99  100  102 107  114  115 120  122  124 127  128  134 139  143  147 150

    第三类测试集样本编号: 34  35  36 37  38  39 40  41  42 43  44  45 46  47  48 49  50

    1.  设定分类规则(一对多还是一对一),并利用迭代法在训练集上设计线性分类器(给出惩罚系数),给出判别函数。同时将测试集中的数据代入判别函数,给出测试的准确率;

    惩罚系数: factor = 0.1

    最终计算的得出的权向量为:

    W1  =  (-15.1156  -13.7006   -1.32033   0.448794  -112.199)T

    W2  =  (-34.1219  -19.1983   -14.6433   -3.18996  101.799)T

    W3  =  (-18.77        1.07      -28.8         -10.58         0.5)T

    判别函数:

    D1(X)= -15.1156x1-13.7006x2-1.32033x3+0.448794x4-112.199

    D2(X)= -34.1219x1-19.1983x2-14.6433x3+-3.18996x4+101.799

    D3(X)= -18.77x1+1.07x2 -28.8x3 -10.58x4+0.5

    测试的准确率:  96.0784%

    2.  设定分类规则(一对多还是一对一),并利用Fisher法在训练集上设计线性分类器,给出判别函数(给出各类的类间离散度矩阵与类内离散度矩阵等参数)。同时将测试集中的数据代入判别函数,给出测试的准确率;

     

    类的类间离散度矩阵:

    Sb =

    类内离散度矩阵:

    第一类类内离散矩阵 :

     

    第一类类内离散矩阵:

     

    第一类类内离散矩阵:

    测试的准确率:  86.28%

    3.  对上述的两种算法进行分析

    感知器算法通过赏罚原则依据每次对训练集的训练不断修正判别函数的权向量,当分类器发生错误分类的时候对分类器进行“罚”,即对权向量进行修改,当感知器正确分类的时候对分类器进行“赏”,对全向量不进行修改。这样经过迭代计算后,通过训练集的训练得到最优的判别函数的权向量。可以从程序上看出感知器算法的实现是十分简单清晰的,而且对测试集的判断正确率也十分理想,高达96%以上。但是感知器一般只用于小样本数据的学习和识别,对于大样本数据感知器算法就显出劣势了。相对于感知器算法的fisher分类算法在样本的判别正确率上要远低于感知器算法,而且fisher算法的内部实现相对于感知器算法要复杂得多,这大多是由于矩阵计算相当消耗计算机资源。Fisher算法在判别上劣于感知器算法主要是样本的训练集并不能达到fisher算法训练的标准。另一个在样本的不平衡条件下,会导致fisher算法的协方差矩阵不好估计,从而导致矩阵计算的误差。从综合性能和判别结果上分析,感知器算法对于小样本的判别要更适合fisher算法,而且在时间和算法复杂度上都要更好些。

    三、      贝叶斯决策(20分)

    保持第二题中已选择的训练集与测试集不变,将所有的样本从4维降低为两维(随机选取两维),将训练集的所有样本点在二维坐标系下标注出来,注意不同的类别用不同形状的点加以区分。

    选取样本的第一维和第二维。


    1.      利用贝叶斯决策与训练集设计分类器,写出判别函数与判别规则。

    判别函数:d(1)= 42.25*x1 - 4.126*x2+13.19x1*x2-9.01*x2*x2-8.73x1*x1-97.21

                    d(2)=19.1*x1 + 10.79*x2-2.489x1*x1-6.145x2*x2+3.888x1*x2-70.71

                    d(3)= 9.813*x1 + 14.42*x2 -1.301x1*x1+5.26x2*x2+2.502x1*x2-5207

    判别规则:

    如果d(1)>d(2) 且d(1)>d(3)则样本属于第一类

                  如果d(2)>d(1)且d(2)>d(3)则样本属于第二类

    如果d(3)>d(1) 且d(3)>d(2)则样本属于第三类

    2.      将判别函数作用于测试集,在二维坐标系下将测试集的数据标注出来,注意不同的类别用不同形状的点加以区分,用深浅不同的灰度表示错分与正确分类的样本点,给出分类的准确率。


    测试样本个数:  51

    错误分类样本个数:9

    分类准确率:82.35%

     

    3.      实验结果分析

    贝叶斯分类决策是通过统计学理论知识中样本的概率问题对样本进行分类判别的。通过样本数据计算样本的后验概率的大小决定样本最终属于的类别。对于正态分布的贝叶斯判别决策更是需要特征空间中某一类样本较多的分布在其均值附近,远离均值样点的个数较少。这样决策才算合理。这使得贝叶斯分类决策十分依赖样本数据。所以对于本实验中4维的数据降到2维,如果选择的维数不同会使得实验结果有较大差距。根据实验结果可以看出某些样本中的两个数据并不能准确的反应这个样本的类别,这导致贝叶斯判别失误。所以在选择样本维数的时候要尽量选择容易区分样本。

     

     

    四、      特征选择(20分)

    1. 保持第二题中已选择的训练集与测试集不变,利用特征选择算法,将样本从4维特征空间降至2维特征空间。给出特征选择的依据与算法过程。并将训练集的所有样本点在二维坐标系下标注出来,注意不同的类别用不同形状的点加以区分。

    2.  特征选择的依据:K-L变换

    3.  算法过程:

    4.      给定样本X后,首先统计并计算其协方差矩阵CX

    5.      求CX的特征根,选取前M个最大的特征根对应的特征向量,这些特征向量构成K-L变换的正交阵

    6.      对X做K-L变换后得到M维向量Y,作为表示原始样本X的特征

     

    7.      选取样本的第二三维作为数据样本:

    8.      

    9.      依然利用贝叶斯决策和训练集设计分类器,写出判别函数。

    判别函数:

    d(1)=27.59*x1 + 47.52*x2 - 0.5*x1*(8.048*x1 -0.161*x2) + 0.5*x2*(0.161*x1 - 32.51*x2) - 80.46

    d(2)= 13.87*x1 + 16.25*x2 + 0.5*x2*(5.176*x1 - 7.096*x2) -0.5*x1*(13.03*x1 - 5.176*x2) - 52.48

    d(3)= 15.63*x1 + 10.69*x2 + 0.5*x2*(2.429*x1 - 3.153*x2) -0.5*x1*(9.992*x1 - 2.429*x2) - 52.22

    10.  将判别函数作用于测试集,在二维坐标系下将测试集的数据标注出来,注意不同的类别用不同形状的点加以区分,用深浅不同的灰度表示错分与正确分类的样本点,给出分类的准确率


    测试样本个数:  51

    错误分类样本个数:4

    分类准确率: 92.16%

    实验结果分析

    从实验结果来看分类效果还是很理想的,对样本数据进行K-L变换后,再进行贝叶斯分类可以发现样本的分类效果比原来更加高效了。但是K-L最佳变换性能虽好,但实现起来不易。样本不同,协方差矩阵就不同,因此对应的变换T也不一样。为了得到最佳变换,每来一个样本就要重复上述步骤,运算相当繁琐。

     

    五、      系统设计(12分)

    1.      任务描述:设计一个模式识别系统,可以识别笔、直尺与橡皮。

    通过采集笔、直尺与橡皮长宽高等数据先利用训练集正态分布贝叶斯决策设计判别函数,然后用设计好的分类器对测试样本进行识别分类。

    2.      基本要求:按照统计类模式识别的基本步骤,从数据采集开始,到特征提取、分类器设计,直至测试结果,给出每一步的具体实现过程。

    (1).数据采集:通过对笔、直尺与橡皮的图片提取图片中物体的长、宽、高或者界面半径的像素个数。

    (2).特征提取: 这里提取样本的长宽比和最小截面面积来作为样本特征数据。其中样本长宽比等于样本长度的像素个数除以样本宽度的像素个数。对于圆形的样本用用截面半径取代样本高度。对最后的样本数据进行归一化。

    二维(x1,x2)T,x1表示样本长宽比,x2表示样本最小横截面积

    直尺

    橡皮

    (10.0 , 2.25)

    (7.0 , 0.3)

    (1.8 ,6.6)

    (12.2 , 2.0)

    (9.4 , 0.25)

    (2.3 , 8.0)

    (9.8 , 1.8)

    (6.0 , 0.4)

    (1.5 , 4.8)

    (19.0 , 2.0)

    (10.5 , 0.32)

    (2.0 , 5.8)

    (11.7 , 1.44)

    (8.5 , 0.34)

    (3.4 , 4.2)

    (14.5 , 2.5)

    (6.2 , 0.5)

    (2.8 , 3.8)

    (10.8 , 1.9)

    (5.8 , 0.28)

    (1.2 , 5.0)

     

    (3).分类器设计:通过正态分布贝叶斯决策对训练集样本进行训练,样本数据为二维(x1,x2)T,x1表示样本长宽比,x2表示样本最小横截面积。计算各个类别的类内散布矩阵和类间散布矩阵。然后获得三个类别的判别函数D(1),D(2),D(3)分别为笔、直尺和橡皮的判别函数。如果D(1)>D(2)&D(1)>D(3),则该样本属于笔;如果D(1)>D(2)&D(1)>D(3),则该样本属于直尺;如果D(1)>D(2)&D(1)>D(3),则该样本属于橡皮。

                  (4).测试结果:

                         笔: 100%

                         直尺: 100%

                         橡皮: 100%

     

    六、      心得体会(8分)

    通过这一个多月的学习,模式识别这门课给我带来的收获还是很多的。特别是这个在完成这个大作业的过程中自己学习到了很多东西。第一个是书本上的理论内容,我梳理了下自己总结的知识点。模式识别过程实际上是计算机通过对采集到的数据进行特征提取后,用模式分类算法构造判别函数(也就是分类器).大作业中有对样本进行分类的k均值算法按最小距离原则依靠聚类中心分类。然后是感知器算法,通过迭代不断修改权向量,最后得到最优的判别函数。Fisher算法对多维数据进行降维处理,找出最优的投影面。贝叶斯决策利用概率论中的知识,通过计算类间离散度和类内离散度,最后得到权向量来判断样本类别。

    其次是为了实现算法中复杂的矩阵计算,除了第一题和第二题的第一小问我是用C语言实现的,后面的程序都是用matlab实现的。当然自己也是一边学习一边使用。编程中遇到了很多困难,都是通过百度查询来解决的。经过几天的摸索,虽然不能说写了这几个算法自己就多精通matlab了,但至少自己已经入门,知道怎么用这个强大的科学计算工具来处理复杂的数学问题。

    当然学习一门新的语言对学习计算机专业的学生来说并不是什么很难的事情,其实最重要的是弄清书中的算法实现。所以在编写程序之前我总要花几个小时来用心了解书中的理论知识。所以学习这门课也培养我钻研知识的能力,以及培养耐心。因为很多程序总是伴随着很多bug,所以你不得不花大量的时间来调试程序。下面我把自己相关的程序附上作为附录。

     

     

    作业相关程序:

    贝叶斯算法:

    clc;clear all;d=2;c=3;N=50;errnum = 0;N1=33;N2=40;N3=26;

    p1 = N1/N;p2 =N2/N;p3=N3/N;D=load('Iris_data.txt');

    data=zeros(150,d);G1=zeros(N1,d);G2=zeros(N2,d);G3=zeros(N3,d);

    hG1=zeros(50-N1,d);hG2=zeros(50-N2,d);hG3=zeros(50-N3,d);

     data(:,1)=D(:,2); data(:,2)=D(:,4);

    for i=1:1:N1 G1(i,:)=data(i,:);end

    for i=1:1:N-N1 hG1(i,:)=data(i+N1,:);end

    for i=1:1:N2  G2(i,:)=data(N+i,:);end

    for i=1:1:N-N2  hG2(i,:)=data(N+N2+i,:);end

    for i=1:1:N3  G3(i,:)=data(2*N+i,:);end

    for i=1:1:N-N3  hG3(i,:)=data(2*N+N3+i,:);end

    miu1=mean(G1,1)miu2=mean(G2,1)miu3=mean(G3,1)

    sigma1=zeros(d,d);sigma2=zeros(d,d);sigma3=zeros(d,d);

    for i=1:1:N1  sigma1=sigma1+(G1(i,:)-miu1)'*(G1(i,:)-miu1);  end

    for i=1:1:N2   sigma2=sigma2+(G2(i,:)-miu2)'*(G2(i,:)-miu2);end

    for i=1:1:N3   sigma3=sigma3+(G3(i,:)-miu3)'*(G3(i,:)-miu3);end

    sigma1=sigma1/N1;sigma2=sigma2/N2;sigma3=sigma3/N3;

    R=zeros(150,3);syms x1 x2 positive;

    temp = [x1    x2];format short;

    d1=log(p1)-1/2*log(det(sigma1))-1/2*(temp*inv(sigma1)*temp')+miu1*inv(sigma1)*temp'-1/2*miu1*inv(sigma1)*miu1';

    d2=log(p2)-1/2*log(det(sigma2))-1/2*(temp*inv(sigma2)*temp')+miu2*inv(sigma2)*temp'-1/2*miu2*inv(sigma2)*miu2';

    d3=log(p3)-1/2*log(det(sigma3))-1/2*(temp*inv(sigma3)*temp')+miu3*inv(sigma3)*temp'-1/2*miu3*inv(sigma3)*miu3';

    fun1 =@(temp)(log(p1)-1/2*(temp-miu1)*inv(sigma1)*((temp-miu1)')-1/2*log(det(sigma1)));

    fun2 =@(temp)(log(p2)-1/2*(temp-miu2)*inv(sigma2)*((temp-miu2)')-1/2*log(det(sigma2)));

    fun3 =@(temp)(log(p3)-1/2*(temp-miu3)*inv(sigma3)*((temp-miu3)')-1/2*log(det(sigma3))');

    sd1 = vpa(d1,4);sd2 =vpa(d2,4);sd3 = vpa(d3,4);

    format shortaxis([0,13,1.8,14]);

    for i=1:1:N-N1  hold on   x1= data(i+N1,1);  x2= data(i+N1,2);

       if fun1([x1,x2])>fun2([x1,x2])&&fun1([x1,x2])>fun3([x1,x2])

            scatter(x2,x1,40,'r','v','filled');else

    scatter(x2,x1,40,[0.3,0,0],'v','filled'); errnum = errnum+1;end  end

    for i=1:1:N-N2  hold on  x1= data(i+N2+N,1);  x2 = data(i+N2+N,2);

        if fun2([x1,x2])>fun1([x1,x2])&&fun2([x1,x2])>fun1([x1,x2])

            scatter(x2,x1,40,'b','^','filled'); else

           scatter(x2,x1,40,[0,0,0.3],'v','filled');

           errnum = errnum+1; end

    end

    for i=1:1:N-N3 hold on   x1 = data(i+N3+2*N,1);  x2 = data(i+N3+2*N,2);

        if fun3([x1,x2])>fun1([x1,x2])&&fun3([x1,x2])>fun2([x1,x2])

            scatter(x2,x1,40,'g','o','filled');else  scatter(x2,x1,40,[0,0.3,0],'o','filled');

           errnum = errnum+1;end

    end errnum

     fisher算法:

     num1= 26;num2 = 40; num3=33;sum=num1+num2+num3;

    p1 =num1/sum;p2=num3/sum;p3=num3/sum; temp = [0,0];

    for i=1:length(data1)  temp = temp+data1(i,:); end

    meandata1 =temp/length(data1); meandata1'temp = [0,0];

     for i=1:length(data2)  temp = temp+data2(i,:);end

     meandata2 = temp/length(data2); meandata2'

     temp = [0,0];for i=1:length(data3)   temp = temp+data3(i,:);end

     meandata3 = temp/length(data3); meandata3'

     S1 = zeros(2);S2 = zeros(2);S3 = zeros(2);

    for i=1:length(data1)

       S1 =S1+(meandata1-data1(i,:))'*(meandata1-data1(i,:));end

    for i=1:length(data2) S2 =S2+(meandata2-data2(i,:))'*(meandata2-data2(i,:));end

    for i=1:length(data3)  S3 =S3+(meandata3-data3(i,:))'*(meandata3-data3(i,:));end

    Sw = S1+S2+S3; meandata0= meandata1*p1+meandata2*p2+meandata3*p3;

    Sb =(meandata1-meandata0)'*(meandata1-meandata0)*p1+...(meandata2-meandata0)'*(meandata2-meandata0)*p2+(meandata3-meandata0)'*(meandata3-meandata0)*p3;W= Sw\Sb; ins1 = W\S1*W;ins2 =W\S2*W;ins3 = W\S3*W;

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

    展开全文
  • 使用fisher算法,进行留一法验证iris数据集,matlab实现。
  • 我需要用fisher算法进行分类判别,spass软件可以实现fisher判别,我怎么才能用php也实现算法呢?
  • fisher 算法的matlab实现

    2013-07-16 16:48:10
    用matlab实现的fisher分类算法
  • 在分析Fisher线性鉴别算法的基础上,以单片机为硬件载体,实现Fisher线性鉴别算法在手写识别中的应用。该系统的硬件部分主要使用STM32F407单片机为核心,编程实现Fisher线性鉴别算法,实验过程中对不同字符进行多次...
  • fisher算法实例

    2009-06-28 20:32:22
    将多维特征空间的点投影到一条直线上进行判别
  • kpca和fisher算法

    2008-12-15 16:05:19
    第一次上传,不知道该怎么描述,主要是kpca和现行提取方法的
  • 它使用 Vagner-Fisher 算法计算 Levenshtein 和编辑器距离。 Levenshtein 距离是将字符串 r 转换为字符串 b 的最小字符替换、删除和插入数量。 编辑器距离计算为 Levenstein 距离,替换权重为 2。您也可以忽略案例。
  • 两类的线形判别问题可以看作是把所有样本都投影到一个方向上 然后在这 个一维空间中确定一个分类的阈值 过这个预置点且与投影方向垂直的超平面就 是两类的分类面 第一个问题如何确定投影方向 这里只讨论两类分类的...
  • fisher判别算法,包括计算样本类内离散度矩阵Si 和 总类内离散度矩阵Sw

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,949
精华内容 3,579
关键字:

fisher算法