精华内容
下载资源
问答
  • 点击上方蓝字关注“公众号”MATLAB基于PCA-LDA模糊神经网络的人脸识别基于PCA-LDA和粗糙集模糊神经网络的人脸识别,一方面在应用前景上是十分广阔的,可以为IT行业创造更好的经济效益。另一方面,它相对于其它的生物...

    点击上方蓝字关注“公众号”

    9671f0bd4a0575c62d7602f40e47650e.gif

    MATLAB基于PCA-LDA模糊神经网络的人脸识别

    基于PCA-LDA和粗糙集模糊神经网络的人脸识别,一方面在应用前景上是十分广阔的,可以为IT行业创造更好的经济效益。

    另一方面,它相对于其它的生物特征识别更加方便。

    至于环境方面,人脸识别对环境并没有什么影响。

    d24154cf70bf4c78b0031d1fc2804ddc.gif

    图像获取功能:该模块的功能是从图像库中获取图片,获取的图像必须能够在开发环境中可以显示,以便进行图像的处理和识别。

    图像预处理功能:该模块的功能包括图像光线强弱的补偿,图像的灰度化处理,去噪,均衡化后的直方图,以此达到图像对比后增强的目的。

    d24154cf70bf4c78b0031d1fc2804ddc.gif

    图像特征提取功能:改模块的功能是在处理后的图像进行训练,然后将训练后的图像的眼睛,鼻子,嘴巴等生物特征提取出来。

    图像识别功能:该模块部分是将需要进行检测的图像的特征提取出来与数据库的图像的特征进行比较,以此达到人脸识别的功能。

    88540b9542b3f18b81ee2c587cf2fecd.gifa453228c1fa7c66f069a03de924a47a0.png471f17868ceacf053ab50ade3662177c.png

    01

    先解压image-base压缩包与.m文件放在一起

    然后在主窗口依次运行以下函数

    saveORLimage.m将ORL人脸库分为测试集ptest和训练集pstudy存为imagedata.mat

    %对28*23的ORL40类人脸库进行缩小,把它保存到imagedata.mat文件,imagedata.mat保存图形数据矩阵pstudy(学习集)
    %ptest(),pclass
    clear all
    %load istudydata
    load itestdata   
    nclass=40; %识别图象的类数        
    %num=10;%每类图象的个数        
    num=5;%每类图象的个数        
    m=1;%图象缩放比例        

    %这里就是原始图像大小
    %将所得的图象数据保存到矩阵pclass中,pclass最后一列代表ORL人脸库每个人脸所属的类别
    k=1;
    if  study==1
    for i=1:nclass
    for j=1:num
    A=imread(strcat('image-base\s',int2str(i),'_',int2str(j),'.bmp'));     

    %连结字符串
    B=take(imresize(A,m));
    C=double(B);
    pclass(k,:)=[C i];
     k=k+1;
    end
    end    
    end
    if  test==1
    for i=1:nclass
    for j=1:num    
     A=imread(strcat('image-base\s',int2str(i),'_',int2str(j+5),'.bmp'));      %连结字符串
    B=take(imresize(A,m));
    C=double(B);
    pclass(k,:)=[C i];
    k=k+1;
    end
    end               
    end
    %学习集pstudy
    k1=1;
    if  study==1
    for i=1:nclass
    for j=1:num          
    pstudy(k1,:)=pclass((i-1)*num+j,:);
    k1=k1+1;
    end
    end
    end
    %测试集ptest
    if  test==1
    for i=1:nclass
    for j=1:num         
     ptest(k1,:)=pclass((i-1)*num+j,:);          
    k1=k1+1;
     end
     end
    end
    if  study==1
    savefile = 'imagepstudydata.mat';
    save(savefile,'pstudy');     

    %将训练数据存进磁盘,pclass要不要呢
    end
    if  test==1
    savefile = 'imageptestdata.mat';
    save(savefile, 'ptest') ;   

    %将测试数据存进磁盘,pclass要不要呢
    end

    513b46884ccef1010d647b16b1e8750e.gif

    01

    1.savelda.m将人脸库先进行pca降维,再用lda进行特征提取,得到新的测试集ldatest和训练集ldastudy存为imageldadata.mat

    if  study==1
    load imagepstudydata;
    end
    if  test==1
    load imageptestdata;
    load imageldaUUata;
    end
    % load imagenewdata
    classnum=40;
    everypersonnums=5;
    pcamaxnums=60;%设定pca最大的前maxnums特征值             
    ldamaxnums=20;

    %lda操作选取的特征数                     
    % pstudy=newpstudy;
    % ptest=newptest;
     %每幅训练图象减去平均值
    if  study==1
    [mstudy,nstudy]=size(pstudy);
    pstudymean=mean(pstudy(:,1:nstudy-1));
    pstudy1=pstudy(:,1:nstudy-1)-pstudymean(ones(mstudy,1),:);
    end
    %每幅测试图象减去平均值
    if  test==1
    [mtest,ntest]=size(ptest);
    ptestmean=mean(ptest(:,1:ntest-1))
    ptest1=ptest(:,1:ntest-1)-ptestmean(ones(mtest,1),:);
    end
    %计算训练样本协方差矩阵及其特征值,特征向量
    if  study==1
    f=(1/sqrt(mstudy))*pstudy1;
    L=f*f';
    [eignvectors,eignvalues] = eig(L);   

    %eignvalues是特征值,对角矩阵;eignvetors是与L同等大小的矩阵,每一列包含特征向量  
     %将特征值从大到小排列
    %  [ee,kk]=sort(diag(eignvalues),'descend');
    [ee,kk]=sort(diag(eignvalues));        

    %diag是对角化;sort是将矩阵的每一列按升序排列,结果存进ee,kk是索引矩阵
        kk=flipud(kk);                         

    %列保持不变,行按头尾顺序对调    
     %取得排列后特征值对应的特征向量
        eigns=eignvectors(:,kk);
     %求投影矩阵
        U=f'*eigns;
    %把矩阵单位化
        for i=1:mstudy                                             
    U(:,i)=U(:,i)/norm(U(:,i));        

    %norm求出U中的最大单数
    end
    %选maxnums个特征向量组成子空间
    UU(:,1:pcamaxnums)=U(:,1:pcamaxnums);
    end
    %以下为LDA部分
    %求pca在训练集上的投影矩阵
    if  study==1
    pcastudy2=pstudy1*UU;
    %计算类间散布矩阵SB
    pcastudy2mean=mean(pcastudy2);%求在测试集上总体平均值
    for i=1:classnum
    k1=(i-1)*everypersonnums+1;            

    %从1至5,这个可以调整           
    k2=(i-1)*everypersonnums+5;
    everypersonmean(i,:)=sum(pcastudy2(k1:k2,:))/everypersonnums;   
    end
    SB=zeros(pcamaxnums,pcamaxnums);
    for i=1:classnum
    SB=SB+everypersonnums*(everypersonmean(i,:)-pcastudy2mean)'*(everypersonmean(i,:)-pcastudy2mean);
    end
    %计算总类内散布矩阵Sw
    SW=zeros(pcamaxnums,pcamaxnums);
    for i=1:classnum
    for j=1:everypersonnums
    SW=SW+(pcastudy2((i-1)*everypersonnums+j,:)-everypersonmean(i,:))' * (pcastudy2((i-1)*everypersonnums+j,:)-everypersonmean(i,:));
    end
    end
    %计算投影矩阵
    bb=(inv(SW))*SB;              

    %方形矩阵翻转
    [beignvectors,beignvalues] = eig(bb);  
    %将特征值从大到小排列
    %[bee,bkk]=sort(diag(beignvalues),'descend');
    [bee,bkk]=sort(diag(beignvalues));
    bkk=flipud(bkk);
    %取得排列后特征值对应的特征向量
    beigns=beignvectors(:,bkk);
    wf(:,1:ldamaxnums)=beigns(:,1:ldamaxnums);
    %求pca在训练集上的投影矩阵
    pcastudy2=pstudy1*UU;
    pcastudy2mean=mean(pcastudy2);
    pcastudy2=pcastudy2-pcastudy2mean(ones(mstudy,1),:);
    end
    %求pca在测试集上的投影矩阵
    if  test==1
    pcatest2=ptest1*UU;    

    %要输UU!
    pcatest2mean=mean(pcatest2);
    pcatest2=pcatest2-pcatest2mean(ones(mtest,1),:);
    end
    if  study==1
    learnfishstudy=pcastudy2*wf;

    % 计算训练样本的PCA+FLD特征向量
    end
    if  test==1
    testfishstudy=pcatest2*wf;

    % 计算测试样本的PCA+FLD特征向量
    end
    %对pca训练集和测试集上的矩阵进行单位化
    if  study==1
    st1=learnfishstudy;
    %  for i=1:size(st1)
    % st1(i,:)=st1(i,:)/norm(st1(i,:));
    %  end
    ldastudy=[st1 double(pstudy(:,nstudy))];
    end
    if  test==1
    st2=testfishstudy;
    % for i=1:size(st2)
    % st2(i,:)=st2(i,:)/norm(st2(i,:));
    % end
    ldatest=[st2 double(ptest(:,ntest))];
    end
    if  study==1
    savefile = 'imageldastudydata.mat';
    save(savefile, 'ldastudy');
    savefile = 'imageldaUUata.mat';
    save(savefile, 'UU','wf');
    end
    if  test==1
    savefile = 'imageldatestdata.mat';
    save(savefile,'ldatest');
    end

    02

    2.对ldastudy进行离散化(discretimage.m),得到离散化矩阵disdata,存入到imagedisdata.mat

    %对整个数据集进行离散化,disattr需要离散化的属性,posattr为挑选出的属性重要度最大的属性,discretSet为离散化属性集
    %disdata为离散化了的属性和决策属性组成的决策表,t为程序运行时间
    t1=cputime;
    load imageldastudydata;
    %载入ldastudy数据
    pstudy=ldastudy;
    [row,col]=size(pstudy);
    %初始化数据集的离散属性集
    disattr=0;
    discretSet=[];
    ndiscretSet=size(discretSet,2);            
    %ndiscretSet等于discretSet向量的第二个值
    lastdata=pstudy(:,col);
    %为决策属性值
    disdata=lastdata;
    ppstudy=pstudy;
    while  ndiscretSet
    ndiscretSet
    disattr=disattr+1;
    %求离散属性集属性重要度最大的属性
    if isempty(discretSet)             
    %判断discretSet是否为空矩阵
    posattr=[];
    else
    [posattr,tt]=calmaxpos(discretSet,disdata);
    end
    nd=size(disdata,2);
    R= [posattr nd];
    %求划分的等价类
    %根据划分的等价类划分数据集
    pset=partset(R,disdata,pstudy);
    %用ncl聚类方法进行聚类
    for i=1:size(pset,2)
    Y=pset{i}(:,1:col-1);
    baseclass=ncl(pset{i}(:,1:col-1),pstudy(:,1:col-1));
    base{i}=baseclass;
    end
    %求属性disattr的取值区间集合
    d1=[];
    for i=1:size(base,2)
    for j=1:size(base{i},2)  
    if iscell(base{i})             
    %判断是否是cell array
    if ~isempty(base{i}{j})
    %qj=calqj(disattr,base{i}{j});
    %求属性disattr在每个聚类的区间
    qj=[min(base{i}{j}(:,disattr)) max(base{i}{j}(:,disattr))];
    end
    else
    %qj=calqj(disattr,base{i});
    qj=[min(base{i}(:,disattr)) max(base{i}(:,disattr))];
    end
    d1=[d1;qj];
    end
    end
    %合并区间
    d=mergeqj(d1);
    %为每个区间编号
    [m1,n1]=size(d);
    disd=[d [1:m1]'];
    %对每个区间按大小依次赋予离散化值1,2,3……
    %对disattr属性进行离散化
    valpca=pstudy(:,disattr);
    for i=1:size(valpca)
    for j=1:size(disd)
    A=disd(j,:);
    x=valpca(i);
    if x==d(m1,2)
    dispstudy(i,disattr)=m1;
    %如果实值x是该属性的最大值,则把x离散化为最大值
    elseif isinset(x,A)
    dispstudy(i,disattr)=A(3);
    %如果实值x属于区间A,则把x离散化为区间A对应的最大值
    end      
    end
    end
    discretSet=[discretSet disattr];
    %将属性disattr加入到离散化属性集discretSet中
    ndiscretSet=size(discretSet,2);
    %求属性集discretSet中属性的个数
    disdata=[dispstudy(:,1:disattr) lastdata];
    %将离散化的属性和决策属性组成决策表
    end
    %保存离散化的数据集disdata和时间t
    savefile = 'imagedisdata.mat';
    save(savefile, 'disdata')
    t2=cputime;
    t=t2-t1;
    savefile1 = 'program_time.mat';
    save(savefile1, 't')

    03

    3.将disdata组成决策表(savers.m),通过对disdata的条件属性进行约简,得到其一个约简,组成新的测试集rstest和训练集rsstudy存为imagersdata.mat

    % %对决策表的条件属性进行约简(求核),得到约简后的数据集rsstudy,rstest
    if  study==1
    load imageldastudydata; %载入ldastudy数据
    end
    if  test==1
    load imageldastudydata;

    %载入ldastudy数据    
    load imageldatestdata;

    %载入ldatest数据
    end
    %load imagepcadata
    load imagedisdata;

    %载入离散化数据
    eta=0.02;
    [row,col]=size(disdata);
    lastdata=disdata(:,col);
    [posattr,tt]=calmaxpos(1:col-1,disdata);
    [T,S]=poscd(1:col-1,col,disdata);

    %求条件属性相对于决策属性的属性重要度T
    Y=[];
    for i=1:size(tt,2)
    if tt(i)~=0
    Y=[Y i];
    end
    end
    [t,s]=poscd(Y,col,disdata);

    %求d的c正域
    ty=setdiff(1:col-1,Y);
    YY=[Y];
    %将条件属性除去相对核约简集组成候选属性集,从候选属性集中挑选候选属性加入到相对核约简集,如果其组成的一个约简属性集的
    %属性重要度大于相对核约简集的属性重要度,而且小于(1-eta)*T,则该属性加入,否则不加入
    for j=1:size(ty,2)
    YY=[YY ty(j)];
    [tt,ss]=poscd(YY,col,disdata);
    if tt>(1-eta)*T
    YY=delattr(ty(j),YY);
    end
    %t=tt;
    end
    if  study==1
    rsstudy=[ldastudy(:,YY) lastdata];
    end
    if  test==1
    rstest=[ldatest(:,YY) lastdata];
    end
    % rsstudy=[pcastudy(:,YY) lastdata];
    % rstest=[pcatest(:,YY) lastdata];
    if  study==1
    savefile = 'imagersstudydata.mat';
    save(savefile, 'rsstudy');           

    %'Y','YY'要不要存进去
    end
    if  test==1
    savefile = 'imagerstestdata.mat';
    save(savefile,'rstest');            

    %'Y','YY'要不要存进去
    end

    04

    4.对rsstudy进行模糊神经网络训练(savecul.m),对模糊神经网络的参数进行调整学习将其存入culdata.mat

    %训练模糊神经网络,得到模糊神经网络的参数nm(所有类的聚类中心),nlen(所有类的聚类宽度),ny(所有类的实数后件)
    load imagersstudydata %载入约简数据
    rspcaclass=[rsstudy];
    [row,col]=size(rspcaclass);
    nclass=40;                     

    %这个需要调整!
    % nclass=30;
    nm=cell(nclass,1);
    nlen=cell(nclass,1);
    ny=cell(nclass,1);
    nstudy=cell(nclass,1);
    nErrHistory=cell(nclass,1);
    for j=1:nclass
    A=rspcaclass(find(rspcaclass(:,col)==j), :);
    %A1=rspcaclass(find(rspcaclass(:,col)~=j), :);
    [nm{j},nlen{j},ny{j},nstudy{j},nErrHistory{j}]=fnnlearn(A,1);
    %[nm{j},nlen{j},ny{j},nstudy{j},nErrHistory{j}]=fnnlearn(A1,0);
    end
    savefile = 'culdata.mat';
    save(savefile, 'nm', 'nlen','ny','nstudy','nErrHistory');

    05

    5.用runfnn.m对rstest进行测试得到其识别率

    %测试模糊神经网络的识别率
    load culdata 

    %载入模糊神经网络参数数据
    load imagerstestdata;

    % 载入约简数据
    cluster_n=2;

    %聚类个数                              

    %这个要研究!
    pcaclass=[rstest];
    nclass=40;

    % 类别数                                

    %这个需要调整!
    [m,n]=size(pcaclass);
    dimension=n-1;
    count=0;
    for i=1:10
    x=pcaclass(i,1:n-1);  
    %计算40个模糊神经网络分类器的输出
    for j=1:nclass
    su=calu(x,nm{j},nlen{j},cluster_n,dimension);
    p(j)=calout(su,ny{j});
    end
    %得到输出最大的分类器
    %返回向量X中最大元素所在的位置
    for  index=1:size(p,2)
    if  p(index)==max(p)
    k=index;
    end
    end
    figure;
    A=imshow(strcat('image-base\s',int2str(k),'_',int2str(1),'.bmp'));
    % %如果输出最大的分类器就是期望的分类器,则识别正确,否则识别错误
    %if k==pcaclass(i,n)
    %count=count+1;   
    %else
    % % p
    % % [pcaclass(i,n) k]
    %end
    end
    % % disp('在整个学习集和测试集上的识别率为:');
    % shibielv=count/m;
    % shibielv
    % % t2=cputime;
    % % t=t2-t1;

    6f57a35e6774782e0da11cc68804117c.png

    6dc8fb3666e7882f03b5216db79d4549.png

    7343e4cde67c5dbc0a54e06fe49958fb.gif

    具体仿真程序链接,微信公众号回复【人脸识别】即可获得链接。

    未完待续

    扫码关注

    不迷路

    e7dbe946e20413a0543e20d013363221.gif

    展开全文
  • 机器学习—PCA和LDA

    2020-08-16 20:24:58
    本篇文章介绍一下机器学习中最为常见的数据降维技术PCA和LDA,随着深度学神经网络的发展PCA和LDA的应用几乎越来越少了,尤其是LDA,但是这两种降维的思想还是值得我们学习的。 PCA 主成分分析(PCA)是一种无监督...

    本篇文章介绍一下机器学习中最为常见的数据降维技术PCA和LDA,随着深度学神经网络的发展PCA和LDA的应用几乎越来越少了,尤其是LDA,但是这两种降维的思想还是值得我们学习的。

    PCA

    主成分分析(PCA)是一种无监督学习的降维方法,其主要思想非常非常简单,即寻找一组正交基对原始数据进行线性变换,使变换后的数据在某一个正交基方向上方差最大,从而尽最大可能地将原始数据投影到该方向上,如下图。
    在这里插入图片描述

    那么,我们如何找到这组正交基呢?

    别急,在寻找正交基之前,我们还需要对数据进行中心化预处理,将所有数据搬移到坐标原点。然后假设在N维空间中的一个单位方向向量为w,我们只需要让所有数据样本在w上的投影方差最大即可。
    在这里插入图片描述
    上式中中间的一大坨不就是协方差矩阵嘛!不过别忘了,我们还有一个约束条件,w的模是等于1的哦,所有优化问题变为如下:
    在这里插入图片描述
    好了,到了我们最拿手的拉格朗日乘子法了,我们把约束问题转为无约束优化问题,即:
    在这里插入图片描述
    呵呵,就这?
    我们发现原来方差的最大值居然是协方差矩阵的最大特征值,那这个事就变简单了,我们只需要先求出协方差矩阵的所有特征值,然后对特征值进行降序排序,最后选出前K(假设我们想将数据降到K维)大的特征值所对应的特征向量即可。但是有的人可能会问,特征向量一定是正交的吗?别忘了,我们的协方差矩阵可是实对称矩阵,学过线性代数的都知道实对称阵是一定可以对角化并存在一组正交基。我们只需计算数据在前K大的特征值所对应的特征向量上的投影这个事情就搞定了。

    嗯,PCA就完事了。

    LDA

    哦豁?LDA是啥?PCA不是已经可以降维了吗?
    别忘了PCA是一种无监督降维方法,而LDA是一种有监督的降维方法,PCA只能通过数据之间的内在关系进行降维,而LDA则可以尽可能的利用标签的信息对数据进行降维。

    线性判别分析(LDA)的思想也很简单,即数据的类间距离最大化,类内距离最小化,说白了,LDA就是想将同类数据紧凑的抱团。

    首先根据标签,我们先计算每一类数据各个特征维度的中心,以二分类为例:
    在这里插入图片描述
    然后计算其投影后的类间距离,
    在这里插入图片描述
    其中
    在这里插入图片描述
    然后计算类内方差:
    在这里插入图片描述
    在这里插入图片描述
    我们希望的目标是,类间方差最大,类内方差最小,因此优化目标可以写为:
    在这里插入图片描述
    令类间散度矩阵为:
    在这里插入图片描述
    类内散度矩阵为:
    在这里插入图片描述
    因此优化目标重新写为
    在这里插入图片描述
    对w求偏导,并令其等于0即可。
    在这里插入图片描述
    于是得出,
    在这里插入图片描述
    令,
    在这里插入图片描述

    在这里插入图片描述
    整理得,
    在这里插入图片描述
    到这里我们发现,目标函数的最大值即为矩阵在这里插入图片描述
    的最大特征值,与PCA类似,我们只需要找出前K大的特征值所对应的特征向量即为我们所求的正交变换矩阵。

    展开全文
  • 本文归纳总结了机器学习在脑电分析中的应用,并详细介绍回归模型,SVM、K近邻、人工神经网络、朴素贝叶斯、决策树随机森林、集成学习、模糊逻辑、LDA线性判别分析、K-means聚类、强化学习、迁移学习等机器学习方法...

    本文归纳总结了机器学习在脑电分析中的应用,并详细介绍回归模型,SVM、K近邻、人工神经网络、朴素贝叶斯、决策树和随机森林、集成学习、模糊逻辑、LDA线性判别分析、K-means聚类、强化学习、迁移学习等机器学习方法的有效性、关键特性及其最适合的应用场景。

    文章来源于2020年发表的《A Review on Machine Learning for EEG Signal Processing in Bioengineering》

    脑电图(EEG)自发现以来,一直是确定患者某些健康状况的主要方法。由于可使用的分类器类型多种多样,因此可采用的分析方法也同样众多。在本文中,我们将研究专门用于脑电分析和生物工程应用的机器学习方法。回顾了1988年至2018年的文献,以获取脑电在多种应用中的先前和当前分类方法。根据这些信息,我们能够确定每种机器学习方法的总体有效性以及关键特性。我们发现机器学习中使用的所有主要方法都以某种形式应用于脑电分类。从朴素贝叶斯到决策树/随机森林,再到支持向量机(SVM)。有监督的学习方法整体上比无监督的学习方法具有更高的准确性,这包括支持向量机和KNN。虽然每一种方法在各自的应用中各自的精度都受到限制,但希望在正确实现方法的同时获得更高的总体分类精度。

    图1 EEG信号采集中的10–20系统的电极排布
    图1 EEG信号采集中的10–20系统的电极排布

    A.概览

    机器学习是利用一组数学模型和算法,逐步提高单个任务的性能。它以训练数据集作为输入,用作估计的指南,而不需要专门编程。任务在这个空间中变化很大,**可以分为两大类:有监督学习和无监督学习。**无监督学习是指算法从只包含输入而不包含输出的数据集建立识别模式。监督学习有一个部分是半监督学习。它们在某种意义上是相同的,即它们都从具有给定输入和已知输出的数据集学习,除了半监督有部分数据集缺失。有监督学习主要用于分类和回归,而无监督学习则用于特征学习和降维。本文将讨论一些最常用的机器学习方法,并根据学习类型对它们进行分类,并将其应用于脑电领域。

    借助机器学习方法,脑电信号可以作为较难检测的病情的指标。在图2中,机器学习在脑电信号上的应用是基于有监督和无监督学习的。有监督学习利用输入和期望输出的数据建立预测模型,分类和回归产生相应的离散和连续。无监督学习提出了一种预测模型,利用输入的数据进行聚类和降维,从而产生相应的离散性和连续性。

    图2 基于监督学习和无监督学习的EEG机器学习应用
    图2 基于监督学习和无监督学习的EEG机器学习应用

    图3描述了机器学习如何实现对所需的数据集进行分类的一般流程。第一步是信号采集。即未经编辑原始数据。然后进行预处理:去除数据集中的噪声和其他异常值。特征提取决定了数据的频谱及其对应的特征。特征选择是分离出所需的分类器,机器学习方法将对这些分类器进行后续训练。机器学习训练涉及到使用训练数据集,无论是否有已知的输出来细化分类方法。最后,测试阶段是处理真实的测试数据集,并比较所需特征的总体精度。

    图3 EEG机器学习分析的整体步骤
    图3 EEG机器学习分析的整体步骤:预处理、特征提取、特征选择、模型训练、模型测试。

    B.回归模型

    回归建模是统计学中一种常用的工具,因为它是创建变量之间函数关系的一种简单方法各种类型的回归包括:

    定量反应变量的单变量回归和多变量回归;

    预测变量的简单和多变量回归;

    线性可转换数据的线性回归;

    非线性可转换数据的非线性回归;

    定性变量预测变量的方差分析;

    定性组合的协方差分析以及定量变量预测因子;

    以及定性反应变量的logistic分析。

    Legendre和Gauss首先应用最小二乘法进行回归。该方法通过求各方程残差的平方和来进行逼近,使数据最为拟合,并应用于线性回归中。如下式所示:
    i=B0+B1xi+ei,i=1,,n i=B_{0}+B_{1} x_{i}+e_{i, i=1, \ldots, n}
    线性回归是最常用的回归方法之一。在这个模型中,参数以线性组合的形式指定,而每个自变量不一定是线性的。多元线性回归与其类似,除了包含多个自变量,而不是只有一个。当参数不是线性时,必须使用非线性回归。使用平方和技术,尽管它使用迭代过程来最小化函数。

    表1 EEG分析中的回归模型应用
    在这里插入图片描述

    C. SVM支持向量机

    支持向量机(SVM)是监督学习的一个子类,用于分类和回归分析。其目的是映射空间中的点,使目标类别的示例被最大可能的差额分割。这使得支持向量机作为分类器具有较低的泛化误差。它的目标是在N维空间中找到一个超平面或一组超平面。**支持向量是更接近给定超平面的数据点。**它们通过改变超平面的位置和方向来最大化分类器的边缘。此外,在这个空间内,由于数据的位置,这些点也可能是不可线性分割的。支持向量机能够利用生成的核函数或更常见的“核技巧”来解决这个问题。这个技巧涉及到现有算法从低维数据集到高维数据集的转换。信息量保持不变,但在这个高维空间中,可以创建线性分类器。每个点都有几个K核,这有助于确定新变换特征空间的最佳拟合超平面。有了足够的K函数,就有可能得到精确的分离。**它唯一的主要问题是过度拟合。**图4描绘了2D和3D中的数据分离的示例。
    wxb=1,1 \vec{w} \cdot \vec{x}-b=1,-1
    硬边界线性支持向量机分类器
    W(α)=i=1lαi+12i=1lj=1lyiyjαiαixixj W(\alpha)=-\sum_{i=1}^{l} \alpha_{i}+\frac{1}{2} \sum_{i=1}^{l} \sum_{j=1}^{l} y_{i} y_{j} \alpha_{i} \alpha_{i} \mathbf{x}_{i} \mathbf{x}_{j}
    最小化W的核函数方程:
    i=1lyiαi=00αiC \begin{array}{c} \sum_{i=1}^{l} y_{i} \alpha_{i}=0 \\ 0 \leq \alpha_{i} \leq C \end{array}
    图4 高维核分离

    图4 高维核分离。内核技巧涉及到现有算法从低维数据集到高维数据集的转换

    D. KNN K近邻

    KNN是一种有监督的机器学习算法。在有监督学习中,已经为训练数据集建立了输入和输出之间的关系,即对于给定的输入,输出是已知的。监督学习分为回归学习和分类学习。KNN既可用于分类,也可用于回归。分类和回归的输入是相同的,但输出是不同的。示例中的输入输出对用于预测未训练数据集的输出。KNN基于K邻居的分类对输入进行分类。为了找到最近的邻居,需要计算从输入到所有已知数据点的欧氏距离或马氏距离。计算距离后,选择K个最近邻。然后根据输入与其K-邻居之间的相似性对输入进行分类。K的选择基于数据集的大小。取数据集大小的平方根,如果结果是偶数,则加上或减去1。然后将该数据集的结果确定为K。选择K为奇数,以避免在预测输入时出现偏差。

    表2 支持向量机在EEG分析中的应用
    在这里插入图片描述

    E. ANN 人工神经网络

    神经网络,在计算机界通常被称为人工神经网络,是一种数学模型,与人脑中的神经网络结构非常相似。为了了解模型的工作原理,研究人员提出了一些理论和例子,说明了神经网络的不同层之间的相互作用,以将给定的输入转换为期望的输出。

    想象一下你在一家酒吧,看着菜单点了一杯好啤酒。你最喜欢的是IPA,当你在列表上看到它时,你就点它。所以在你的大脑中发生的事情是,你为你的大脑神经网络提供了多种啤酒选择的输入,IPA的选择有一个可取的重量,因为那是你最喜欢的啤酒;大脑做出决定并给你输出。这是神经网络运作的一个基本例子。模型的体系结构显示了决策过程,其中涉及到输入层和输出层之间更深层的交互。图5示出了ANN的不同层的分类。
    在这里插入图片描述

    图5 一种具有输入层、隐含层和输出层的前向神经网络

    从神经网络的数学模型可以看出,在第一层的任何给定输入都要经过该算法提出的函数,该函数将缩小多个组合和选项的范围,以描述期望的输出。这可以在图6中观察到。对于ANN,分类技术可以通过以下方式实现:

    输入权重乘积和偏差的总和:
    i=1n(wixi)+ bias  \sum_{i=1}^{n}\left(w_{i} x_{i}\right)+\text { bias }
    激活层
     Output =f(x)={1ifwx+b00ifwx+b<0 \text { Output }=f(x)=\left\{\begin{array}{l} 1 i f \sum w x+b \geq 0 \\ 0 i f \sum w x+b<0 \end{array}\right.

    在这里插入图片描述
    图6 对输入节点、隐藏节点和输出节点三种类型的神经网络进行结构分解

    与其他有监督和无监督的学习技术相比,神经网络通过将数据分离到预定的最深层次来提供最优化的结果。现代一代已经成功地识别和记录了许多技术,包括使用人工神经网络对脑电信号进行分析和分类,并模拟不同医疗条件下的结果。脑电信号或通常称为脑电图是一组高度复杂的信号,研究这些信号可以发现人脑活动的异常。后者是在大脑中的神经元开始放电并在树突内产生电流时测量的。因此,这种电流会在头皮上产生一个磁场,这个磁场通过一个信号发生器被记录下来,这个信号发生器在大脑的任何一个特定位置都会产生活动。这些信号需要针对我们关注的异常类型进行研究和分离,为此,我们正在讨论可用于不同脑电应用的不同机器学习模型。与传统的脑电分析方法相比,对脑电信号进行正确的分类和分析是当务之急。标准程序包括脑电信号的时频分析和频谱分析。EEG的特征波形落在特定的频带上,即alpha(8~15Hz)、beta(14~30HZ)、theta(4~8Hz)和delta(<4Hz),以往的分类方法如FFT(快速傅立叶变换)具有很高的噪声敏感性,限制了对信号的有效分析。因此,**如何利用神经网络或人工神经网络来有效地测量脑电的活动性成为人们关注的焦点。**本节讨论了神经网络在脑电数据综合中的应用,并根据不同信号的属性和特征对其进行分类。正如我们现在所知道的,**ANN****的工作原理是分析针对多种可能性和连接提供的数据集,以根据需要提供最佳输出。**网络架构的主要特征取决于以下几个突出的因素:

    1.输入信号类型(信号维数和行为)

    2.连接的拓扑结构

    3.不同网络层之间的交互

    4操作方式

    5输出解释

    由于每个应用的不同,必须有一种特定的方法可以很容易地使用神经网络进行定位和合成。一旦脑电信号图转换成波形后,便可通过神经网络对这些信号进行分类,并针对特定的用例选择特定类型的网络——**前向神经网络、径向基函数、递归神经网络。**重要的是了解不同类型的人工神经网络是如何运作的,以及促进这种运作的架构。

    表3 ANN在EEG分析中的应用
    在这里插入图片描述

    前向神经网络

    这是一种网络类型,数据只向一个方向流动,从输入节点开始,经过隐藏节点,到达输出节点。这个网络确保没有循环或循环的形成,使信息只在特定的方向流动。

    在这里插入图片描述
    图7 前向神经网络

    信息流有两个方向,前向传播和后向传播。预测时间采用前向传播,后向传播调整权值以使损失最小化。

    径向基函数

    在人工神经网络和数学建模领域,径向基函数是一种利用径向基函数(一个任意的实值函数,其值由函数从原点处的位置决定)的神经网络。因此,该网络通过输入和神经元参数的RBF线性组合来确定输出。如图8所示,该结构通过将点的中心/宽度与相关权重相加来操作,以获得最终输出。

    典型的RBF是高斯分布,在标量输入的情况下,由:
    h(x)=exp((xc)2r2) h(x)=\exp \left(\frac{-(x-c)^{2}}{r^{2}}\right)
    其中c是中心,r是半径参数。高斯径向基函数分布随距离中心的增加而减小。

    对于具有标量输入的多二次RBF,可以显示为:
    h(x)=r2+(xc)2r h(x)=\frac{\sqrt{r^{2}+(x-c)^{2}}}{r}
    在这种情况下,高斯径向基函数随着距中心距离的增加而增加。
    在这里插入图片描述

    图8 径向基函数网络

    这是一种以径向基函数作为激活函数的神经网络。神经网络的输出采用径向基函数和神经元参数的线性组合。这些结构有许多应用,如时间序列预测,分类和函数逼近。

    循环神经网络(RNN)

    RNN(Recurrent Neural Networks)是一种在不同节点之间建立连接的人工神经网络,具有特定的输出流向。在这里,数据循环可以反馈给特定的节点。在图9中示出了该技术,其示出了信息从一个层到另一层以及到特定预定节点的反向传播。

    在这里插入图片描述
    图9 递归神经网络

    其中节点之间的连接形成一个沿时间序列的有向图。它使之前的输出被用作输入。

    要理解RNN的工作原理,必须定义从一个先前状态到新状态的转换。设Xt为输入向量,Ht为新状态,Ht-1为前一状态。RNN是输入向量和前一状态的函数,它将使我们进入新状态Ht。我们可以通过获得权重函数Fw并实现该函数以找到输出函数Yt来表示RNN的一个简单的版本。具体表现为:
    ht=fw(ht1,xt) h_{t}=f_{w}\left(h_{t-1}, x_{t}\right)
    ht=tanh(Whhht1+Wxhxt) h_{t}=\tanh \left(W_{h h} \cdot h_{t-1}+W_{x h} \cdot x_{t}\right)
    通过应用tan双曲函数,即先前状态关联权重的点积,以及关联权重与输入状态的点积,我们将得到新状态的值。最终输出函数为:
    yt=Whyht y_{t}=W_{h y} \cdot h_{t}

    F.朴素贝叶斯

    朴素贝叶斯分类器是一种常见的文本分类方法,它将贝叶斯定理应用于基于简单训练特征的数据分离。本质上,该模型在一个有限的集合中指定标签作为特征向量。虽然简单,但有足够的预处理,它可以匹配更先进的方法,如上面讨论的支持向量机。朴素贝叶斯方法的一个缺点是,它认为所有的特征向量都是相互独立的,而不考虑任何实际的相关性它的主要优点是只需要少量的训练数据就可以开始正确估计分类所需的参数。贝叶斯方法可以实现几个模型,其中最常见的是概率模型。在该模型中,特征由向量表示,并将概率分配给给定的结果或案例。**事件模型可以分为两类:高斯朴素贝叶斯和多项式朴素贝叶斯。**在具有连续值的数据集中,一个好的假设是它遵循高斯分布。使用这种方法,贝叶斯方法根据曲线分配概率。多项式事件模型表示由多项式产生的特定事件的频率,通常是直方图。一个潜在的问题是:当一个特征根本没有出现在数据集中,这将导致所有估计值的倍数为零。它可以用伪计数进行校正,以消除数据集中的任何异常值。
    P(cx)=P(x)(c)P(x) P(c \mid x)=\frac{P(x) \mid(c)}{P(x)}
    概率朴素贝叶斯模型
    P(x=vCk)=12πσk2e(vμk)22σk2 P\left(x=v \mid C_{k}\right)=\frac{1}{\sqrt{2 \pi \sigma_{k}^{2}}} e^{-\frac{\left(v-\mu_{k}\right)^{2}}{2 \sigma_{k}^{2}}}

    表4 朴素贝叶斯在EEG分析中的应用
    在这里插入图片描述

    G.决策树和随机森林

    **决策树使用关于项目特征的问题来分类数据。**每个问题都可以表示为一个节点,其中每个问题的答案都有一个子节点。这将创建层次结构,换句话说,树,最基本的树是二叉树,**每个问题都有一个是或否的答案。**因此,每个父节点问题都有一个“是”和“否”子节点。通过从最顶层的节点(也称为根节点)开始,向下移动到叶子或没有子节点的节点,对数据进行排序。所采用的路径取决于数据的功能。一旦数据到达叶,就可以将其分类到与该特定叶相关联的类下。
    在这里插入图片描述
    图10 决策树技术确定健康状况的示例

    决策树的优点是它们简单,可以很容易地与其他决策技术相结合。决策树的缺点是它们有点不稳定,也不准确,特别是不同的层次大小会导致对更大层次的偏差。

    在机器学习和不同的分类和分布方法的研究中,我们遇到了随机森林技术,它可以用于数据分类和回归操作。顾名思义,**随机森林是通过产生大量的决策树来进行操作的,并通过bagging操作来训练,将多个决策树或模型组合起来,从而得到更稳定、更准确的数据预测。**随机森林为被构造的数据创建了额外的随机性;也就是说,它不是从给定的集合中找到最重要的特征,而是在定义的特征子集的随机集合中寻找最佳特征。这就产生了一个更加多样化和更好的结果模型。

    在这里插入图片描述
    图11 随机森林

    它是一种集成学习方法,主要用于分类和回归。它通过在数据集的不同子样本上创建多种决策树来操作,并使用多数投票或平均来查找输出。该模型提高了预测精度,并能控制过拟合。

    表5 决策树和随机森林的应用概览
    在这里插入图片描述

    H.集成学习

    集成学习是一种有监督的学习算法。顾名思义,**集成学习集成了许多不同的算法,使模型具有更好的预测性能。**总体思路是通过组合从不同的多个模型接收到的决策来提高整体性能。它基于多样性的概念,**与单一模型相比,考虑了更多不同的模型来获得同一问题的结果。**这给出了一组假设,这些假设可以组合起来以获得更好的性能。所有的单一模型被称为基础学习者,当组合被称为一个集成时,这个合奏比组成合奏的基础学习者大多要好。集成学习可以应用于医学、欺诈检测、银行、恶意软件和入侵检测、人脸和情感识别等领域。

    表6 集成学习应用概览
    在这里插入图片描述

    I.模糊逻辑

    模糊逻辑是一种机器学习技术,它通过在0.0到1.0之间分配一系列真值来分离给定的数据。这种方法不仅依靠指定一个确定的真值或假值(二进制值0或1)来接受或拒绝数据。相反,它还通过指定一个真实值的程度来决定正当性,例如数据不是完全真实的,但在某种程度上可以被某个值视为真实的。考虑下面的例子:我们有两种已知的蓝色色调:浅蓝色和深蓝色。如果您正在训练您的计算机,以确定给定输入(海蓝)的确切蓝色,我们可以为该输入指定一个0.0到1.0的真值,该值表示输入可以接近所需真彩色的80%。

    在这里插入图片描述

    图12 模糊系统示例

    在这里插入图片描述

    图13 模糊系统操作

    几乎所有的家用机器或设备(如空调、洗衣机等)都是在模糊逻辑的概念上运行的。这种逻辑被输入到一个通常称为模糊系统控制的控制系统中,其中的每个组件被设计用来运行和改变另一个物理操作系统,以达到预期的功能。为了了解模糊系统是如何工作的,有必要分析系统需求和使用模糊系统的意图。要使一个系统成为一个以知识为基础的功能元素,具有应用人类认知过程(如推理和思考)的能力,就必须有一个稳定的组件,能够为一组给定的输入变量提供真实程度方面的输出。从控制理论到人工智能,模糊逻辑被观察到在机器学习领域的许多应用中被实现。这是一个精确模拟人类大脑的思考和推理能力。为了使模糊系统有效地工作,需要保证以下特性和部件的性能:

    模糊集

    模糊集被认为与成员函数相对应,成员函数定义在变量集的模糊空间中。**成员函数的特点是为定义良好的模糊集合中的任何元素提供一定程度的隶属度。然后,成员函数为这些元素分配一个介于0到1之间的数值,**其中0表示对应的元素不是模糊集合中的元素,或者1表示对应的元素是模糊集合中的元素。

    模糊规则

    模糊逻辑的作用方式是由一组应用模糊规则定义的,它决定了由IFTHEN规则指定的输出。**观察IF-THEN规则来创建一个由模糊逻辑组成的条件语句。例如,IF-THEN假设X和Y是预期项,并用范围为U和V的模糊集的项进行求值,这将语句分为前因和后果两部分。这形成了一个规则:如果X是U,那么Y就是V。但是,这些规则是基于自然语言和模型表示,基于给定的模糊集和逻辑。

    模糊逻辑推理或模糊推理系统(FIS)

    一旦定义了模糊规则集和隶属函数,就可以实现过程仿真和控制,并根据所提供的数据或知识类型来完成。FIS系统通常分为三个阶段:

    在第一阶段,提供给系统的数值输入变量被映射成与各自模糊集的相容程度,这就是所谓的模糊化过程。这个过程允许系统以模糊易读的语言术语表达输入和输出。

    在第二阶段,系统根据每个输入变量的强度对规则进行处理。

    在第三阶段,通过去模糊化过程将得到的模糊值转换回数值。此过程因此将模糊域输出映射回crisp域,从而使输出变得清晰。

    模糊分数

    FIS系统的输出以模糊分数的形式表示,对于已知由系统生成的所有个人输入分数。FIS系统通过考虑所有定义的模糊约束和隶属函数来计算模糊分数。分数取决于应用的规则类型和输入变量的类型。FIS根据模糊规则准则为每个输入变量分配一个分数。研究发现,典型的模糊系统作为机器学习的主要应用是在脑电信号的模式识别中,模糊逻辑可以用来确定不同阶段脑电分类的正确识别率。然而,模糊逻辑和神经网络的结合通常被称为神经模糊系统,系统可以应用模糊参数(如模糊集、模糊规则)并将其与神经网络逼近技术相结合进行广泛的分析。神经模糊系统被发现是非常有益的医疗条件诊断,密度和回归估计,模式识别和数据分析。

    表7 模糊逻辑在EEG分析中的应用
    在这里插入图片描述

    J. LDA线性判别分析

    对于一个随机变量选择范围很广的给定数据集,需要进行降维处理,以减少特定主变量的参数个数,从而缩小数据集的维数空间。由于数据的分类方法有很多种,因此**降维技术主要有两种:主成分分析法和线性判别法分析。PCA和LDA具有相似的功能和应用。然而,LDA技术可以处理类内频率不需要相等的情况,突出的因素是它在类间方差和类间方差之间提供了一个高比率和显著的分离。PCA与LDA的主要区别在于,PCA更适用于特征分类,LDA更适用于数据分类。

    表8 线性判别分析
    在这里插入图片描述
    最常用的降维技术是线性判别分析(LDA)。这项技术背后的主要标准是在不同类别之间提供良好的可分性,并避免曲线过拟合。通过将给定的具有n维样本的特征空间投影到一个精确且更小的特征子空间,这将大大降低计算成本并提供更好的分类。在典型的主成分分析中,数据集的位置、形状和结构都会发生完全的变化。但对于LDA来说,当数据集被转换成不同的更小的空间时,该技术可以保持数据集的位置和形状。这是通过在变换后的空间上定义一组向量来区分和分离的。在LDA技术中,通常采用两种不同的方法:

    ​ **1.**类别独立转换:这种方法主要关注提高总体方差与类内方差的比率,只使用一个准则来优化数据集转换过程。这将转换所有必需的数据点,而不考虑它们的类。所以在这里,每个类都被认为是独立于所有其他类的。

    **2.**类别相关变换:这种方法的主要目的是提高类变量与类内变量的比值,为脑电信号分析和BCI(脑机接口)应用提供足够的分类可分性范围,探索有效分离和分离多变量数据集的先进方法。**接收到的脑电信号可能会受到噪声干扰而失真,必须对其进行有效的分离,才能得到准确的结果。为此,正在实施降维技术,以减少数据集并将不需要的信号频率从感兴趣的频率中分离出来。

    K.K-Means

    K-means是一种用于聚类问题的无监督学习方法。它的工作方式是使用一种算法来定位一个分区,以最小化聚类的经验平均值和其中的点之间的误差。使用这些K个聚类,K-means试图最小化平方误差的总和。

    在这里插入图片描述
    图14 K-means聚类法

    有两种常用的初始化方法:Forgy和Random分区。在上述方法中,K个观测值是从数据集中随机选取的,然后将这些观察结果用作初始手段。

    K-means的一个优点是,由于K相对较小,它易于实现较高的计算速度。K-means的一些缺点包括初始条件对最终输出的高显著性、对缩放的敏感性以及数据顺序与最终结果之间的相关性。

    表9 K-means在EEG分析中的应用
    在这里插入图片描述

    L. RL强化学习

    机器学习可分为三类:有监督学习、无监督学习和强化学习。强化学习使用给定的数据为环境选择一个能产生最大预期长期回报的行动。强化学习比给定的数据更关注性能。对于给定的数据,强化学习可以描述为有监督学习和无监督学习的结合。强化学习可能有,也可能没有已知的结果输入/输出对。

    在这里插入图片描述
    图15 强化学习操作

    一个典型的强化学习设置由S表示的可能状态,A是可能的动作集合,Delta:SA给出的状态转移函数,SAS给出的趋向于R的奖励函数,以及定义趋向于动作A的状态的策略pi。

    表示如下:
    δ:S×ASr:S×A×SRπ:SA \begin{array}{c} \delta: S \times A \rightarrow S \\ r: S \times A \times S \rightarrow \mathbb{R} \\ \pi: S \rightarrow A \end{array}
    使用RL模型的优点之一是它保持了探索和利用之间的平衡,其他有监督的算法无法实现这种平衡。在脑电分析应用中,RL模型已经显示出不断向脑-机接口系统的控制机制发展,在状态转换和最佳功能的奖励机制之间保持平衡。

    M.方法的结合

    方法的结合包括使用两个或多个机器学习算法来利用每种方法所具有的独特特性。这允许多模式算法提取额外的期望特征。多模式集成的意义在于,它允许使用主要已经存在的方法进行高分辨率分类。此外,该分辨率通常高于单独的方法。然而,多模式提取并非没有限制。由于算法的复杂性增加,可能很难确定真正的准确度,因为它不能直接与现有的方法相比较。

    展开全文
  • 实际工作中,待测数据可能已知,也可能未知 逻辑回归整体最优(最高准度第2,平均准度第1,结果稳定,速度ok) 独热编码优于词向量 独热编码tfidf优于count 线性svm训练时间过长,结果不稳定 ...主题模型LDA是垃圾

    前言

    上篇文本分类实验结果
    本篇首发日期:2020-9-27
    本篇实验详细结果及代码
    本篇python版本:3.7.4
    本篇sklearn版本:0.21.3
    本篇keras版本:2.3.1

    语料

    统计

    类别 数量 类别 数量
    science 2093 car 2066
    finance 2052 sports 2017
    military 2007 medicine 2000
    entertainment 1906 politics 1865
    education 1749 fashion 1712

    待测数据是否已知?

    • 实际工作中,待测数据可能已知,也可能未知,其监督学习方法可以有所不同
    • 此实验待测数据已知
    训练
    预测
    特征工程
    训练
    训练
    预测
    待测数据未知
    标注数据
    有监督学习模型
    未知数据
    待测数据已知
    未标注数据+标注数据
    特征
    有监督学习模型
    标注数据
    未标注数据

    代码

    TFIDF+【贝叶斯、逻辑回归、决策树、随机森林】

    from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer
    from sklearn.naive_bayes import MultinomialNB
    from sklearn.linear_model import LogisticRegression
    from sklearn.tree import DecisionTreeClassifier
    from sklearn.ensemble import RandomForestClassifier
    from sklearn.svm import SVC
    import jieba, warnings
    from segment import tk
    from data10 import load_xy
    warnings.filterwarnings('ignore')  # 不打印警告
    DISCARD_FLAG = {'c', 'd', 'e', 'o', 'p', 'r', 'u', 'uv', 'y', 'NUM'}  # 词性排除
    N = 25000  # 最大词数
    
    
    def cut1(text):
        for word in tk.cut(text):
            if tk.get_flag(word) not in DISCARD_FLAG:
                yield word
    
    
    def cut2(text):
        words = tk.lcut(text)
        for i in range(len(words) - 1):
            yield words[i]
            yield words[i] + words[i + 1]
        yield words[-1]
    
    
    def cut_flag(text):
        for word in tk.cut(text):
            flag = tk.get_flag(word)
            if tk.get_flag(word) not in DISCARD_FLAG:
                yield word
                yield flag
    
    
    def experiment(test_size=.5, random_state=7):
        x, (train, test, y_train, y_test) = load_xy(test_size, random_state)
        vec_ls = (
            CountVectorizer(tokenizer=tk.cut, max_features=N),
            CountVectorizer(tokenizer=cut1, max_features=N),
            CountVectorizer(tokenizer=cut2, max_features=N),
            CountVectorizer(tokenizer=cut_flag, max_features=N),
            CountVectorizer(tokenizer=jieba.cut, max_features=N),
            TfidfVectorizer(tokenizer=tk.cut, max_features=N),
            TfidfVectorizer(tokenizer=cut1, max_features=N),
            TfidfVectorizer(tokenizer=cut2, max_features=N),
            TfidfVectorizer(tokenizer=cut_flag, max_features=N),
            TfidfVectorizer(tokenizer=jieba.cut, max_features=N),
        )
        clf_ls = (
            MultinomialNB(),
            LogisticRegression(solver='liblinear'),
            DecisionTreeClassifier(),
            RandomForestClassifier(),
            SVC(kernel='linear'),
        )
        for x_fit in (train, x):
            for vec in vec_ls:
                vec.fit(x_fit)
                x_train = vec.transform(train)
                x_test = vec.transform(test)
                for clf in clf_ls:
                    t0 = tk.second
                    clf.fit(x_train, y_train)
                    print(clf.__class__.__name__, tk.second - t0, clf.score(x_test, y_test))
                tk.yellow(vec)
    
    
    experiment()
    

    词向量+TFIDF+【贝叶斯、逻辑回归、决策树、随机森林、SVM】

    from gensim.models import Word2Vec
    from math import log10
    from sklearn.linear_model import LogisticRegression
    from sklearn.tree import DecisionTreeClassifier
    from sklearn.ensemble import RandomForestClassifier
    from sklearn.svm import SVC
    import numpy as np, copy, warnings
    from segment import tk, clean
    from data10 import load_xy
    warnings.filterwarnings('ignore')  # 不打印警告
    DISCARD_FLAG = {'c', 'd', 'e', 'o', 'p', 'r', 'u', 'uv', 'y', 'NUM'}
    
    
    def cut1(text):
        for word in tk.cut(text):
            if tk.get_flag(word) not in DISCARD_FLAG:
                yield word
    
    
    class Word2Vector:
        def __init__(self, cut, size=75, window=7, min_count=3):
            self.size = size
            self.window = window
            self.min_count = min_count
            self.cut = cut
            self.wv = None
            self.vectors = None
            self.w2i = None
    
        def unit_vector(self):
            self.vectors = self.vectors / np.linalg.norm(self.vectors, axis=1).reshape(-1, 1)
    
        def idf(self, texts):
            texts = [set(self.cut(t)) for t in texts]
            lent = len(texts)
            self.vectors = self.vectors * np.array(
                [[log10(lent / (sum((w in t) for t in texts) + 1))] for w in self.wv.index2word])
    
        def fit(self, texts):
            sentences = [list(self.cut(s)) for t in texts for s in clean.text2clause(t)]  # 文本切分
            wv = Word2Vec(sentences, size=self.size, window=self.window, min_count=self.min_count).wv  # 词向量
            self.w2i = {w: i for i, w in enumerate(wv.index2word)}
            self.vectors = wv.vectors
            self.wv = wv
    
        def text2vector(self, texts):
            return [[self.vectors[self.w2i[w]] for w in self.cut(t) if w in self.w2i] for t in texts]
    
        def vector_sum(self, texts):
            return [np.sum(v, axis=0) if v else np.zeros(self.size) for v in self.text2vector(texts)]
    
        def vector_mean(self, texts):
            return [np.mean(v, axis=0) if v else np.zeros(self.size) for v in self.text2vector(texts)]
    
    
    def experiment(test_size=.5, random_state=7):
        x, (train, test, y_train, y_test) = load_xy(test_size, random_state)
        vec_ls = (
            Word2Vector(tk.cut),
            Word2Vector(cut1),
            Word2Vector(tk.cut, 150),
            Word2Vector(cut1, 150),
        )
        clf_ls = (
            LogisticRegression(solver='liblinear'),
            DecisionTreeClassifier(),
            RandomForestClassifier(),
            SVC(kernel='linear', max_iter=500),
            SVC(max_iter=1000),
        )
        for x_fit in (train, x):
            for vec in vec_ls:
                vec.fit(x_fit)
                # sum
                tk.yellow('*****sum')
                x_train, x_test = vec.vector_sum(train), vec.vector_sum(test)
                for clf in clf_ls:
                    t0 = tk.second
                    clf.fit(x_train, y_train)
                    print(clf.__class__.__name__, tk.second - t0, clf.score(x_test, y_test))
                # mean
                tk.yellow('*****mean')
                x_train, x_test = vec.vector_mean(train), vec.vector_mean(test)
                for clf in clf_ls:
                    t0 = tk.second
                    clf.fit(x_train, y_train)
                    print(clf.__class__.__name__, tk.second - t0, clf.score(x_test, y_test))
                # sum unit_vector
                tk.yellow('*****sum unit_vector')
                vec1 = copy.deepcopy(vec)
                vec1.unit_vector()
                x_train, x_test = vec1.vector_sum(train), vec1.vector_sum(test)
                for clf in clf_ls:
                    t0 = tk.second
                    clf.fit(x_train, y_train)
                    print(clf.__class__.__name__, tk.second - t0, clf.score(x_test, y_test))
                # mean unit_vector
                tk.yellow('*****mean unit_vector')
                x_train, x_test = vec1.vector_mean(train), vec1.vector_mean(test)
                for clf in clf_ls:
                    t0 = tk.second
                    clf.fit(x_train, y_train)
                    print(clf.__class__.__name__, tk.second - t0, clf.score(x_test, y_test))
                del vec1
                # sum idf
                tk.yellow('*****sum idf')
                vec.idf(x_fit)
                x_train, x_test = vec.vector_sum(train), vec.vector_sum(test)
                for clf in clf_ls:
                    t0 = tk.second
                    clf.fit(x_train, y_train)
                    print(clf.__class__.__name__, tk.second - t0, clf.score(x_test, y_test))
                # mean idf
                tk.yellow('*****mean idf')
                x_train, x_test = vec.vector_mean(train), vec.vector_mean(test)
                for clf in clf_ls:
                    t0 = tk.second
                    clf.fit(x_train, y_train)
                    print(clf.__class__.__name__, tk.second - t0, clf.score(x_test, y_test))
    
    
    experiment()
    

    CNN、GRU、LSTM、双向GRU、双向LSTM

    from keras.utils import to_categorical
    from keras.preprocessing.sequence import pad_sequences
    from keras.models import Sequential
    from keras.layers import Dense, LSTM, GRU, Bidirectional, Conv1D, MaxPool1D, GlobalMaxPool1D, Embedding
    from keras.callbacks import EarlyStopping
    from sklearn.model_selection import train_test_split
    import collections, warnings
    from segment import tk, clean
    from data10 import load_xy
    warnings.filterwarnings('ignore')
    
    """配置"""
    N = 25000  # 最大词数
    input_dim = N + 1  # 词库大小
    output_dim = 150  # 词嵌入维度
    kernel_size = 7  # 卷积核大小
    units = filters = 64  # RNN神经元数量、卷积滤波器数量
    maxlen = 200  # 序列长度
    batch_size = 128  # 每批数据量大小
    epochs = 999  # 训练最大轮数
    verbose = 2  # 训练过程展示
    patience = 1  # 没有进步的训练轮数
    callbacks = [EarlyStopping('val_acc', patience=patience)]
    DISCARD_FLAG = {'c', 'd', 'e', 'o', 'p', 'r', 'u', 'uv', 'y', 'NUM'}
    C = ['science', 'car', 'finance', 'sports', 'military', 'medicine', 'entertainment', 'politics', 'education', 'fashion']
    num_classes = len(C)
    
    
    def cut1(text):
        for clause in clean.SEP45(text):
            for word in tk.cut(clause):
                if tk.get_flag(word) not in DISCARD_FLAG:
                    yield word
    
    
    """读数据"""
    x, (x1, x2, y1, y2) = load_xy()
    y1 = to_categorical([C.index(i) for i in y1], num_classes)
    y2 = to_categorical([C.index(i) for i in y2], num_classes)
    # 词编码
    w2i = {wf[0]: e for e, wf in enumerate(collections.Counter(w for t in x for w in cut1(t)).most_common(N), 1)}
    # pad
    x1 = pad_sequences([[w2i[w] for w in cut1(t) if w in w2i] for t in x1], maxlen, dtype='float')
    x2 = pad_sequences([[w2i[w] for w in cut1(t) if w in w2i] for t in x2], maxlen, dtype='float')
    # 验证集切分
    validation_size = .1
    x11, x12, y11, y12 = train_test_split(x1, y1, test_size=validation_size)
    
    
    def experiment():
        for layer, layer_name in (
            (LSTM(units), 'LSTM'),
            (GRU(units), 'GRU'),
            (Bidirectional(LSTM(units)), 'BiLSTM'),
            (Bidirectional(GRU(units)), 'BiGRU'),
        ):
            tk.cyan(layer_name)
            # 建模
            model = Sequential()
            model.add(Embedding(input_dim, output_dim, input_length=maxlen, input_shape=(maxlen,)))
            model.add(layer)
            model.add(Dense(units=num_classes, activation='softmax'))
            model.compile('adam', 'categorical_crossentropy', ['acc'])
            # 训练、预测
            history = model.fit(x11, y11, batch_size, epochs, verbose, callbacks, validation_data=(x12, y12))
            e = len(history.history['acc'])
            print(model.evaluate(x2, y2, batch_size, verbose), e)
            # 验证集加入训练、预测
            model.fit(x12, y12, batch_size, int(e * validation_size) + 1, verbose, callbacks)
            tk.yellow(model.evaluate(x2, y2, batch_size, verbose))
        # CNN
        tk.cyan('CNN')
        model = Sequential()
        model.add(Embedding(input_dim, output_dim, input_length=maxlen, input_shape=(maxlen,)))
        model.add(Conv1D(units, kernel_size * 2, padding='same', activation='relu'))
        model.add(MaxPool1D(pool_size=2))  # strides默认等于pool_size
        model.add(Conv1D(units * 2, kernel_size, padding='same', activation='relu'))
        model.add(GlobalMaxPool1D())  # 对于时序数据的全局最大池化
        model.add(Dense(num_classes, activation='softmax'))
        model.compile('adam', 'categorical_crossentropy', ['acc'])
        # 训练、预测
        history = model.fit(x11, y11, batch_size, epochs, verbose, callbacks, validation_data=(x12, y12))
        e = len(history.history['acc'])
        print(model.evaluate(x2, y2, batch_size, verbose), e)
        # 验证集加入训练、预测
        model.fit(x12, y12, batch_size, int(e * validation_size) + 1, verbose, callbacks)
        tk.yellow(model.evaluate(x2, y2, batch_size, verbose))
    
    
    experiment()
    

    词向量+【CNN、GRU、LSTM、双向GRU、双向LSTM】

    from gensim.models import Word2Vec
    from keras.utils import to_categorical
    from keras.preprocessing.sequence import pad_sequences
    from keras.models import Sequential
    from keras.layers import Dense, LSTM, GRU, Bidirectional, Conv1D, MaxPool1D, GlobalMaxPool1D
    from keras.callbacks import EarlyStopping
    from sklearn.model_selection import train_test_split
    import numpy as np, warnings
    from math import log10
    from segment import tk, clean
    from data10 import load_xy
    warnings.filterwarnings('ignore')
    
    """配置"""
    size = 150  # 词向量维度
    window = kernel_size = 7  # 词窗、卷积核大小
    units = filters = 64  # RNN神经元数量、卷积滤波器数量
    maxlen = 200  # 序列长度
    batch_size = 128  # 每批数据量大小
    epochs = 999  # 训练最大轮数
    verbose = 2  # 训练过程展示
    patience = 1  # 没有进步的训练轮数
    callbacks = [EarlyStopping('val_acc', patience=patience)]
    DISCARD_FLAG = {'c', 'd', 'e', 'o', 'p', 'r', 'u', 'uv', 'y', 'NUM'}
    C = ['science', 'car', 'finance', 'sports', 'military', 'medicine', 'entertainment', 'politics', 'education', 'fashion']
    num_classes = len(C)
    
    
    def cut1(text):
        for word in tk.cut(text):
            if tk.get_flag(word) not in DISCARD_FLAG:
                yield word
    
    
    """读数据"""
    x, (x1, x2, y1, y2) = load_xy()
    y1 = to_categorical([C.index(i) for i in y1], num_classes)
    y2 = to_categorical([C.index(i) for i in y2], num_classes)
    
    """词向量"""
    sentences = [list(cut1(s)) for t in x for s in clean.text2clause(t)]  # 文本切分
    wv = Word2Vec(sentences, size=size, window=window, min_count=3, sg=1).wv
    vectors = wv.vectors
    texts = [set(cut1(t)) for t in x]
    lent = len(texts)
    vectors = vectors * np.array([[log10(lent / (sum((w in t) for t in texts) + 1))] for w in wv.index2word])  # idf
    w2i = {w: i for i, w in enumerate(wv.index2word)}
    # pad
    x1 = pad_sequences([[vectors[w2i[w]] for w in cut1(t) if w in w2i] for t in x1], maxlen, dtype='float')
    x2 = pad_sequences([[vectors[w2i[w]] for w in cut1(t) if w in w2i] for t in x2], maxlen, dtype='float')
    # 验证集切分
    validation_size = .1
    x11, x12, y11, y12 = train_test_split(x1, y1, test_size=validation_size)
    
    
    def experiment():
        for layer, layer_name in (
            (LSTM(units), 'LSTM'),
            (GRU(units), 'GRU'),
            (Bidirectional(LSTM(units), input_shape=(maxlen, size)), 'BiLSTM'),
            (Bidirectional(GRU(units), input_shape=(maxlen, size)), 'BiGRU'),
        ):
            tk.cyan(layer_name)
            # 建模
            model = Sequential()
            model.add(layer)
            model.add(Dense(units=num_classes, activation='softmax'))
            model.compile('adam', 'categorical_crossentropy', ['acc'])
            # 训练、预测
            history = model.fit(x11, y11, batch_size, epochs, verbose, callbacks, validation_data=(x12, y12))
            e = len(history.history['acc'])
            print(model.evaluate(x2, y2, batch_size, verbose), e)
            # 验证集加入训练、预测
            model.fit(x12, y12, batch_size, int(e * validation_size) + 1, verbose, callbacks)
            tk.yellow(model.evaluate(x2, y2, batch_size, verbose))
        # CNN
        tk.cyan('CNN')
        model = Sequential()
        model.add(Conv1D(units, kernel_size * 2, padding='same', activation='relu'))
        model.add(MaxPool1D(pool_size=2))  # strides默认等于pool_size
        model.add(Conv1D(units * 2, kernel_size, padding='same', activation='relu'))
        model.add(GlobalMaxPool1D())  # 对于时序数据的全局最大池化
        model.add(Dense(num_classes, activation='softmax'))
        model.compile('adam', 'categorical_crossentropy', ['acc'])
        # 训练、预测
        history = model.fit(x11, y11, batch_size, epochs, verbose, callbacks, validation_data=(x12, y12))
        tk.yellow(model.evaluate(x2, y2, batch_size, verbose))
        # 验证集加入训练、预测
        model.fit(x12, y12, batch_size, len(history.history['acc']) - 1, verbose, callbacks)
        tk.yellow(model.evaluate(x2, y2, batch_size, verbose))
    
    
    experiment()
    

    无监督

    词向量+预设规则

    from gensim.models import Word2Vec
    from collections import Counter
    from segment import tk, clean
    
    DISCARD_FLAG = {'c', 'd', 'e', 'o', 'p', 'r', 'u', 'uv', 'y', 'NUM'}  # 词性排除
    THRESHOLD = .5
    
    
    def cut(text):
        for word in tk.cut(text):
            if tk.get_flag(word) not in DISCARD_FLAG:
                yield word
    
    
    def texts2sentences(texts):
        return [list(cut(s)) for t in texts for s in clean.text2clause(t)]
    
    
    class Model:
        def __init__(self, texts, keywords, themes):
            # 加入词库
            for word in keywords:
                tk.add_word(word)
            # 训练词向量
            self.wv = Word2Vec(texts2sentences(texts), window=11, sg=1).wv
            # 词库扩展
            self.dt = {w: {w: 1} for w in keywords}
            for word in keywords:
                for w, s in self.wv.similar_by_word(word, 99):
                    if s < THRESHOLD:
                        break
                    self.dt[w] = dict({word: s ** 2}, **self.dt.get(w, dict()))
            print(self.dt)
            self.themes = themes
    
        def ner(self, text):
            # 抽取扩展后的关键词
            c1 = Counter(w for w in cut(text) if w in self.dt)
            # 扩展后的关键词映射到原关键词
            c2 = Counter()
            for k1, v1 in c1.items():
                for k2, v2 in self.dt[k1].items():
                    c2[k2] += v1 * v2
            return c2.most_common()
    
        def extract_theme(self, text):
            themes = Counter()
            for w, f in self.ner(text):
                themes[self.themes[w]] += f
            return themes and themes.most_common()[0][0]
    
    
    # 读数据
    from pandas import read_excel
    ay = read_excel('data10/data10.xlsx').values
    x, y = ay[:, 0], ay[:, 1]
    WORDS = {
        '车': 'car', '车型': 'car', '汽车': 'car',
        '教育': 'education', '学生': 'education', '学校': 'education', '考生': 'education',
        '娱乐': 'entertainment', '观众': 'entertainment', '饰演': 'entertainment', '演员': 'entertainment',
        '电影': 'entertainment', '角色': 'entertainment', '影片': 'entertainment', '导演': 'entertainment',
        '肌肤': 'fashion', '时尚': 'fashion', '搭配': 'fashion', '穿': 'fashion', '裙': 'fashion',
        '珠宝': 'fashion', '装修': 'fashion', '保湿': 'fashion', '时髦': 'fashion', '面膜': 'fashion', '香水': '时尚',
        '比赛': 'sports', '球队': 'sports', '队': 'sports', '球员': 'sports', '体育': 'sports', '赛季': 'sports',
        '症状': 'medicine', '治疗': 'medicine', '临床': 'medicine',
        '疾病': 'medicine', '患者': 'medicine', '综合征': 'medicine',
        '科技': 'science', '研究': 'science', 'iPhone': 'science', '手机': 'science',
    }
    # 算法
    model = Model(x, WORDS.keys(), WORDS)
    y_predict = [model.ner(i) for i in x]
    print(sum(y == y_predict) / len(y))
    while True:
        try:
            x = x[int(input('输入数字').strip())]
            print(x, '\n\033[033m{}\033[0m'.format(model.ner(x)))
        except:
            pass
    

    主题模型

    LDA是垃圾
    LDA是垃圾
    LDA是垃圾
    LDA是垃圾
    LDA是垃圾
    LDA是垃圾
    LDA是垃圾
    主题模型是垃圾
    主题模型是垃圾
    主题模型是垃圾
    主题模型是垃圾
    主题模型是垃圾
    主题模型是垃圾
    主题模型是垃圾
    主题模型是垃圾

    from gensim import corpora, models
    from segment import tk, clean
    import numpy as np
    
    DISCARD_FLAG = {'a', 'ad', 'c', 'd', 'e', 'f', 'i', 'l', 'nb', 'm', 'o', 'p', 'r', 'u', 'uv', 'y', 'NUM', 'NA'}
    
    
    def cut(text):
        for clause in clean.text2clause(text):
            for word in tk.cut(clause):
                if (tk.get_flag(word) not in DISCARD_FLAG) and (len(word) > 1):
                    yield word
    
    
    def experiment(texts, themes):
        words_ls = [list(cut(t)) for t in texts]
        # 构造词典
        dictionary = corpora.Dictionary(words_ls)
        # 基于词典,使【词】→【稀疏向量】,并将向量放入列表,形成【稀疏向量集】
        corpus = [dictionary.doc2bow(words) for words in words_ls]
        # lda模型,num_topics设置主题的个数
        lda = models.ldamodel.LdaModel(corpus=corpus, num_topics=10, id2word=dictionary)
        # 打印所有主题,每个主题显示20个词
        topics = lda.print_topics(num_words=20)
        for topic in topics:
            print(topic)
        # 主题对应编号(手动输入)
        dt = dict()
        _themes = ['science', 'car', 'finance', 'sports', 'military', 'medicine',
                   'entertainment', 'politics', 'education', 'fashion']
        for i in range(10):
            print(topics[i])
            j = int(input('{}'.format([k for k in enumerate(_themes)])).strip())
            dt[i] = _themes[j]
            del _themes[j]
    
        # 主题推断
        inference = np.argmax(lda.inference(corpus)[0], axis=1)
        inference = [dt[i] for i in inference]
        print(np.mean(themes == inference))
    
    
    # 读数据
    from pandas import read_excel
    ay = read_excel('data10/data10.xlsx').values
    x, y = ay[:, 0], ay[:, 1]
    experiment(x, y)
    

    实验结果和结论

    • 逻辑回归整体最优(最高准度第2,平均准度第1,结果稳定,速度ok)
    • 独热编码优于词向量
    • 独热编码tfidf优于count
    • 线性svm训练时间过长,结果不稳定
    • 独热tfidf+线性svm准度最优
    • 深度学习的训练轮数不易确认,导致不稳定
    • 数据量较少情况下深度学习的准确度较机器学习低
    • 词向量相当于降维,低维空间上,逻辑回归和线性SVM效果一般,高斯核函数SVM效果更好但不稳定
    • 无监督学习中,【词向量+专家系统】有76%的准确率
    • 主题模型是垃圾!LDA是垃圾LDA是垃圾LDA是垃圾LDA是垃圾LDA是垃圾LDA是垃圾
    展开全文
  • 微博文本分析可视化 0.数据来源结构 新浪微博,爬虫链接: 微博内容数据结构(mongo数据库导出的json文档) content_example: [ {'_id': '1177737142_H4PSVeZWD', 'keyword': 'A股', 'crawl_time': '2019-06-01...
  • 使用高级分析算法(如大规模机器学习、图形分析统计建模等)来发现探索数据是当前流行的思路,在IDF16技术课堂上,英特尔公司软件开发工程师王以恒分享了《基于Apache Spark的机器学习及神经网络算法应用》的...
  • 点击上方蓝字关注“公众号”MATLAB基于PCA-LDA模糊神经网络的人脸识别基于PCA-LDA和粗糙集模糊神经网络的人脸识别,一方面在应用前景上是十分广阔的,可以为IT行业创造更好的经济效益。另一方面,它相对于其它的生物...
  • 是一种浅层的神经网络模型,他有2种网络结构,分别是CBOW(continues bag of words) skip-gram. Word2vec 隐狄利克雷模型(LDA),CBOW,Skip-gram Word2vec是如何工作的? CBOW的目标是根据上下文出现的词语来预测...
  • 针对人体行为识别问题,提出一种基于径向基函数(BP)神经网络的人体行为分类算法。首先,利用奇异值分解(SVD)算法提取视频每一帧的奇异值,将每一帧的奇异值按照行拼接起来即为一个视频的样本,样本按照行排成...
  • Word2Vec实际 是一种浅层的神经网络模型,它有两种网络结构,分别是CBOW(Continues Bag of Words)Skip-gram。 知识点 Word2Vec,隐狄利克雷模型(LDA),CBOW,Skip-gram 问题 Word2Vec是如何工作的?它和LDA有...
  • 2.Word2Vec与LDA的区别联系 2.1 主题模型与词嵌入方法 总述: Word2Vec是2013年谷歌提出来目前最为常用的词嵌入模型之一。 Word2Vec是一种浅层的神经网络模型,包含有两种网络结构:CBOW(Continues Bag ...
  • 在许多场合,朴素贝叶斯(Naïve Bayes,NB)分类算法可以与决策树和神经网络分类算法相媲美,该算法能运用到大型数据库中,而且方法简单、分类准确率高、速度快。 朴素贝叶斯算法 设每个数据样本用一个n维特征向量来...
  • 对数几率回归考虑分类问题时使用对数几率回归。 在二分类问题中,其输出标记y(0, 1), 而在线性回归中,输出标记y是实值,所以我们需要将问题转为单位阶跃函数 但是可以看出,单位阶不连续,所以我们...LDA的思想
  • 邻域保持嵌入(Neighborhood Preserving Embedding,NPE),作为局部线性嵌入(Locally ...在ORLYaleB人脸库上的实验结果表明,改进的算法较PCA、LDA、LPP以及原保持近邻判别嵌入算法的识别性能有了较明显的改善。
  • 本文内写过一些机器学习相关的文章,但上一篇技术文章“LDA主题模型”还是写于2014年11月份,毕竟自2015年开始创业做在线教育后,太多的杂事、琐碎事,让我一直想再写点技术性文章但每每恨时...
  • 基于LDA的人脸识别算法研究

    千次阅读 2020-03-01 15:49:37
    研究者们从各种不同的途径提出了多种方法,其中主要有:基于模板匹配的方法,基于知识的人脸验证的方法,以及目前比较流行的基于统计的学习方法基于神经网络的方法等。在基于统计方法的识别方法中,PCA、LDA方法是...
  • 本设计为基于matlab的人脸识别系统,可读取ORL或者YALE人脸库或者自己的人脸,采用的方法可以通过下拉框形式切换成PCA,KPCA,LDA,K-L,BP神经网络多种方式,计算识别率,也可以调用笔记本自带摄像头进行识别。...
  • 本设计为基于matlab的人脸识别系统,可读取ORL或者YALE人脸库或者自己的人脸,采用的方法可以通过下拉框形式切换成PCA,KPCA,LDA,K-L,BP神经网络多种方式,计算识别率,也可以调用笔记本自带摄像头进行识别。...
  • 机器之心分析师网络分析师:王子嘉编辑: H4O基于统计学的主题模型诸如 LDA(Latent Dirichlet Allocation),...同时,随着神经网络的发展,encoding-decoding, GAN 这种非监督模型开始进入到主题模型的应用中来,...
  • 本设计为基于matlab的人脸识别系统,可读取ORL或者YALE人脸库或者自己的人脸,采用的方法可以通过下拉框形式切换成PCA,KPCA,LDA,K-L,BP神经网络多种方式,计算识别率,也可以调用笔记本自带摄像头进行识别。...
  • 分类与预测在R语言中的数据挖掘部分占有很大比重,除前面介绍的分类预测函数外,还有其它分类预测函数: lda 功能:构建一个线性判别分析模型。 格式:lda(formula, data, …, na.omit) 其中,formula根据数据...
  • 3.使用NLP进行Quora问题分类-神经网络 深度学习,文本挖掘,自然语言处理。 使用Spacy和NLTK进行文本数据预处理(计数向量化,标记化,词干和词法化)。 使用LDA和NMF深度学习库执行主题建模和主题标记。 使用grid...
  • NLP 中文短文本分类项目实践(下)

    千次阅读 2018-07-03 02:46:00
    在《NLP 中文短文本分类项目实践(上)》中,我们主要分享了词云、LDA 主题模型朴素贝叶斯 SVM 的分类,本次 Chat,我将带领大家继续文本分类的内容。...中文文本分类之神经网络 CNN LSTM 实战。 ...
  • 生成式判别式

    2019-02-14 17:53:12
    常见判别模型有:线性回归、决策树、支持向量机SVM、k近邻、LDA,CRF,神经网络等; 生成式模型(Generative Model):对联合分布概率p(x,y)进行建模, 常见生成式模型有:隐马尔可夫模型HMM、朴素贝叶斯模型、高斯...
  • 深度学习复习

    2020-06-09 18:26:07
    分类性能度量 ...全连接网络卷积神经网络 反向传播原理 联系 卷积神经网络 原理知识 卷积计算 正则化 权重衰减 L12正则 数据增强提前终止 Dropout 循环神经网络 原理知识 自编码

空空如也

空空如也

1 2 3 4 5
收藏数 94
精华内容 37
关键字:

lda和神经网络