精华内容
下载资源
问答
  • 特征选择算法

    2020-05-28 10:42:11
    启发式搜索 序列向前选择 序列向后选择 双向搜索 增L去R选择算法 序列浮动选择 决策树 完全搜索 分支限界搜索
    展开全文
  • 特征选择算法综述

    2021-02-21 02:59:35
    特征选择算法综述
  • matlab 特征选择算法 序列浮动前向选择算法 SFFS
  • 融合特征排序的多标记特征选择算法
  • 光谱的变量选择/特征选择算法
  • 这类问题中要求特征选择算法不仅能够帮助分类器提高分类准确率,同时还要尽可能地减少冗余特征。因此,为了在分类问题中更好地进行特征选择,提出了一种新型的包裹式特征选择算法XGBSFS。该算法借鉴极端梯度提升...
  • 特征选择算法mRMR.rar

    2020-06-24 10:02:28
    MRMR算法 MATLAB代码,特征选择算法,MRMR算法的实现,注释清楚且可成功运行,运行不了可联系博主。
  • 特征选择是机器学习的一个重要领域,改代码是经典无监督特征选择算法LaplacianScore算法matlab代码,这里上传给大家下载,希望能对大家有所帮助
  • 6 特征选择6.1 问题对“threethreelarge.m”数据,采用任意一种特征选择算法,选择2个特征6.2 思路采用简单特征选择法(simple feature selection approach),首先计算每一个特征的分类能力值,再选择出其中最大分类...

    提供了模式识别特征选择和特征提取详尽的matlab算法代码实现。

    6 特征选择

    6.1 问题

    对“threethreelarge.m”数据,采用任意一种特征选择算法,选择2个特征

    6.2 思路

    采用简单特征选择法(simple feature selection approach),首先计算每一个特征的分类能力值,再选择出其中最大分类能力的l个特征。

    6.3 结果

    eigs = 8.9234 0.0000 0.0767

    SelectedFeature = 1 3

    也就是说,选取x和z坐标作为特征。

    6.4 代码

    % 特征选择代码,见FSthrthrlrg.m文件

    m1=[0,0,0]; m2=[0,0,0]; m3=[0,0,0]; m=[0,0,0];

    for i=1:200

    m1(1)=m1(1)+(x1(i,1)-m1(1))/i;

    m1(2)=m1(2)+(x1(i,2)-m1(2))/i;

    m1(3)=m1(3)+(x1(i,3)-m1(3))/i;

    end;

    for i=1:190

    m2(1)=m2(1)+(x2(i,1)-m2(1))/i;

    m2(2)=m2(2)+(x2(i,2)-m2(2))/i;

    m2(3)=m2(3)+(x2(i,3)-m2(3))/i;

    end;

    for i=1:210

    m3(1)=m3(1)+(x3(i,1)-m3(1))/i;

    m3(2)=m3(2)+(x3(i,2)-m3(2))/i;

    m3(3)=m3(3)+(x3(i,3)-m3(3))/i;

    end;

    m(1)=(m1(1)+m2(1)+m3(1))/3;

    m(2)=(m1(2)+m2(2)+m3(2))/3;

    m(3)=(m1(3)+m2(3)+m3(3))/3;

    sw1=zeros(3,3); sw2=zeros(3,3); sw3=zeros(3,3); sw=zeros(3,3); sb=zeros(3,3);

    for i=1:200

    sw1=sw1+([x1(i,1),x1(i,2),x1(i,3)]-m1)'*([x1(i,1),x1(i,2),x1(i,3)]-m1);

    end;

    for i=1:190

    sw2=sw2+([x2(i,1),x2(i,2),x2(i,3)]-m2)'*([x2(i,1),x2(i,2),x2(i,3)]-m2);

    end;

    for i=1:210

    sw3=sw3+([x3(i,1),x3(i,2),x3(i,3)]-m3)'*([x3(i,1),x3(i,2),x3(i,3)]-m3);

    end;

    N1=200; N2=190; N3=210; N=N1+N2+N3;

    展开全文
  • 一个好的特征选择算法的两个因素是:它的准确性和稳定性。 本文旨在介绍一种稳定特征选择算法的新方法。 本文的创新集中于一类稳定的特征选择算法,即称为特征权重的正则化基于能量的学习(FREL)。 研究了使用L1或...
  • Relief特征选择算法

    2020-05-16 17:45:07
    Relief特征选择算法 Relief算法最早由Kira提出,最初局限于两类数据的分类问题。Relief算法是一种特征权重算法(Feature weighting algorithms),根据各个特征和类别的相关性赋予特征不同的权重,权重小于某个阈值的...

    Relief特征选择算法

    Relief算法最早由Kira提出,最初局限于两类数据的分类问题。Relief算法是一种特征权重算法(Feature weighting algorithms),根据各个特征和类别的相关性赋予特征不同的权重,权重小于某个阈值的特征将被移除。Relief算法中特征和类别的相关性是基于特征对近距离样本的区分能力。算法从训练集D中随机选择一个样本R,然后从和R同类的样本中寻找最近邻样本H,称为Near Hit,从和R不同类的样本中寻找最近邻样本M,称为NearMiss,然后根据以下规则更新每个特征的权重:如果R和Near Hit在某个特征上的距离小于R和Near Miss上的距离,则说明该特征对区分同类和不同类的最近邻是有益的,则增加该特征的权重;反之,如果R和Near Hit在某个特征的距离大于R和Near Miss上的距离,说明该特征对区分同类和不同类的最近邻起负面作用,则降低该特征的权重。以上过程重复m次,最后得到各特征的平均权重。特征的权重越大,表示该特征的分类能力越强,反之,表示该特征分类能力越弱。Relief算法的运行时间随着样本的抽样次数m和原始特征个数N的增加线性增加,因而运行效率非常高。具体算法如下所示:
    在这里插入图片描述
    ReliefF算法实现代码如下:

    import pandas as pd
    import numpy as np
    import numpy.linalg as la
    import random
    
    
    def Relief_F(dataSet,featnames):#使用reliefF算法计算属性的权重值,根据阈值选出最佳的特征子集
    
        dataSet=dataSet.values#将数据框转换为数组
        
        feature=len(featnames)#特征数量
    
        m=5#m:样本抽样次数
        k=5#k:最近邻样本数
    
        feat_class=['b1','b2','b3','b4','b5','b6','b7','b8','b9','pred_minus_obs_H_b1','pred_minus_obs_H_b2','pred_minus_obs_H_b3','pred_minus_obs_H_b4','pred_minus_obs_H_b5','pred_minus_obs_H_b6','pred_minus_obs_H_b7','pred_minus_obs_H_b8','pred_minus_obs_H_b9','pred_minus_obs_S_b1','pred_minus_obs_S_b2','pred_minus_obs_S_b3','pred_minus_obs_S_b4','pred_minus_obs_S_b5','pred_minus_obs_S_b6','pred_minus_obs_S_b7','pred_minus_obs_S_b8','pred_minus_obs_S_b9','class']
        
        weight_vecate=[]#特征权重向量
        
        weight_list=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]#初始化特征权重列表中的每个特征
        for l in range(m):#遍历抽样次数
            #print(l)
            
            temp1=0
            temp3=0
            
            k_min_dist=[]#同类中的k个最近距离列表
            class_sample_list=[]#与R同一类别的样本
            k_min_dist_list=[]#与R同类的样本列表
            k_min_dist_sample_list=[]#存储同类中k个最近邻样本
            every_class_k_min_list=[]#存储与R不同类的每个类的k个最近邻
            
            R=random.choice(dataSet)#在数据集中随机选择一个样本作为R
            R=list(R)
            #print(R)
            
            c=R[-1]#随机选择的样本的类别
            for j in dataSet:#遍历数据集
                if(j[-1]==c):#在数据集中寻找与随机选择的样本R同一类的样本
                    class_sample_list.append(list(j))#与R同一类别的样本放在一起
            del(R[-1])#删除R中的类别           
            for x in class_sample_list:#遍历与R是同一类的样本,找出从R的同类中k个最近邻Hj
                #计算R与其同类别中其他样本的距离,并选出k个最近的样本
                    del(x[-1])#删除每一个与R同类别的样本的类别
                    v1=np.array(R)
                    v2=np.array(x)
                    dist=np.linalg.norm(v1-v2)#计算R与同类其他样本的距离
                    k_min_dist.append(dist)#距离列表
                    k_min_dist_list.append(x)#样本列表
              
            for u in range(len(k_min_dist)-1):#对距离列表和样本列表进行排序
                for d in range(len(k_min_dist)-1-u):
                    if(k_min_dist[d]<k_min_dist[d+1]):#比较紧邻的两个距离
                        temp1=k_min_dist[d+1]
                        k_min_dist[d+1]=k_min_dist[d]
                        k_min_dist[d]=temp1
                        temp2=k_min_dist_list[d+1]
                        k_min_dist_list[d+1]=k_min_dist_list[d]
                        k_min_dist_list[d]=temp2
                
            k_min_dist_sample_list=k_min_dist_list[-k:]#获取同类中k个距离最近的样本
            #print(k_min_dist_sample_list)
            
            #从每个不同类中找出k个最近邻Mjc
            dataSet_train_list=[]
            
            classList=[]
            #将训练集按照类别的不同进行划分
            for i_d in dataSet:#将数组型的数据集转化为列表
                dataSet_train_list.append(list(i_d))    
            classList=[example[-1] for example in dataSet_train_list]#数据集类别列表
            classList=list(set(classList))#去重后的类别列表
            classList.remove(c)#删除R对应类别后的类别
    
    
            for i_c in classList:#遍历除过R的类别的其他每个类别
                dataSet_wp=[]
                for wp in dataSet:
                    dataSet_wp.append(list(wp))
                    
                other_class_dist_list=[]
                every_data=[]
                other_min_dist_sample_list=[]
                other_k_min_dist_sample_list=[]
                
                for dwp in dataSet_wp:#遍历所有样本
                    if(dwp[-1]==i_c):#当数据样本j的类别为i
                        every_data.append(dwp)#获取该类别的样本
        
                for c in every_data:#遍历该类别中的每个样本
                    del(c[-1])#删除样本的类别
                    v3=np.array(R)
                    v4=np.array(c)
                    other_class_dist=np.linalg.norm(v3-v4)#计算R与该类别中一个样本的距离
                    other_class_dist_list.append(other_class_dist)#距离列表
                    other_min_dist_sample_list.append(c)#样本列表
                   
                for v in range(len(other_class_dist_list)-1):#对距离和对应的样本进行排序
                    for w in range(len(other_class_dist_list)-1-v):
                        if(other_class_dist_list[w]<other_class_dist_list[w+1]):
                            temp3=other_class_dist_list[w+1]
                            other_class_dist_list[w+1]=other_class_dist_list[w]
                            other_class_dist_list[w]=temp3
                            temp4=other_min_dist_sample_list[w+1]
                            other_min_dist_sample_list[w+1]=other_min_dist_sample_list[w]
                            other_min_dist_sample_list[w]=temp4
                   
                    
                other_k_min_dist_sample_list=other_min_dist_sample_list[-k:]#选择距离最小的k个样本
                   
                every_class_k_min_list.append(other_k_min_dist_sample_list)#保存与R不同类的每个类别,每个类别中保存该类别中的猜错近邻的样本 
            #print(every_class_k_min_list)
                
            
            for i in range(feature):#遍历每个特征 
                diff_Hj=0
                diff_Hj_list=[]
                #print(R[i])
                for kmdsl in k_min_dist_sample_list:#遍历与R同类中k个最近邻样本
                    #print(w[i])
                    if(kmdsl[i]==R[i]):#当R的第i个特征值与同类最近邻样本值相同
                        diff=0
                    if(kmdsl[i]!=R[i]):#当R的第i个特征值与同类最近邻样本值不同
                        diff=1
                    diff_Hj_list.append(diff)#将计算得到的同类的diff值放到diff_Hj_list
                #print(diff_Hj_list)
                #print(diff_Hj)
                #print(sum(diff_Hj_list))
                diff_Hj=sum(diff_Hj_list)/(k*m)        
                #print(diff_Hj)
                
                
                
                all_class_sample_list=[]
                for cl in range(len(classList)):#遍历与R不同类的每个类别
                    every_class_sample_list=[]
                    for j_d in dataSet:#遍历所有样本
                        if(j_d[-1]==classList[cl]):#当样本j的类别为i
                            every_class_sample_list.append(list(j_d))#获取该类别的样本
                    #print(len(every_class_sample_list))
                    all_class_sample_list.append(every_class_sample_list)#按照类别对样本进行划分成不同的类别小组
                #print(all_class_sample_list)
                
                prob_list=[]
                
                for i_a in range(len(all_class_sample_list)):
                    prob=0
                    prob_R=0
                    pro=0
                    prob=len(all_class_sample_list[i_a])/float(len(dataSet))#每个与R是不同类的类别所占的比例p(c)
                    prob_R=len(class_sample_list)/float(len(dataSet))#R的类别所占比例p(class(R))
                    pro=prob/(1-prob_R)
                    prob_list.append(pro)#每个与R不同类的样本的P(c)/(1-p(class(R)))
                    
               # print(prob_list)
                
                diff_Mj_sum_list=[]
                #print(R[i])
                for s in every_class_k_min_list:#遍历其他每个类别
                    diff_Mj_list=[]
                    diff_Mj_one_sum=0
                    
                    for mm in s:#遍历其他每个类别中的k个近邻
                        #print(j[i])
                        if(mm[i]==R[i]):#当第k类中第j个最近邻样本的特征i与R的第i个特征值相同
                            diff=0
                        if(mm[i]!=R[i]):
                            diff=1
                        diff_Mj_list.append(diff)#存放与R不同类中k个猜错近邻与R的距离
                       # print(diff_Mj_list)
                    diff_Mj_one_sum=sum(diff_Mj_list)#对R不同类中的k个猜错近邻与R的距离求和
                   # print(diff_Mj_one_sum)
                    diff_Mj_sum_list.append(diff_Mj_one_sum)
               # print(diff_Mj_sum_list)
                
                c_list=[]
                diff_Mj=0
                for l1,l2 in zip(prob_list,diff_Mj_sum_list):
                    c=0
                    c=l1*l2
                    c_list.append(c)    
               # print(c_list)
                diff_Mj=sum(c_list)/(m*k)
               # print(diff_Mj)
                
                #print(weight_list[i])
                weight_list[i]=weight_list[i]-diff_Hj+diff_Mj#计算得出特征i的权重
               # print(weight_list[i])
                #weight_list.append(weight_list[i])#将一个特征每一次抽样计算出的特征权重放到权重列表中
               # print('********************************************')
            print(weight_list)    
            print('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~')
            weight_vecate=weight_list
        print(weight_vecate)
        
        
        
        Feature_subset_list=[]
        #将特征权重向量中的中位数作为特征权重阈值
        sorted_weight_vecate=sorted(weight_vecate)#对特征权重列表进行排序 
        print(sorted_weight_vecate)
        if(len(sorted_weight_vecate)%2!=0):#当特征个数是奇数个,则取排序后中间的特征值作为特征权重阈值
            g=int(len(sorted_weight_vecate)/2)#特征权重阈值向量的中位数下标
            threshold_value=sorted_weight_vecate[g]#将中间的特征对应的特征权重作为权重阈值 
        elif(len(sorted_weight_vecate)%2==0):#否则当个数是偶数个,取排序后最中间的两个特征权重值的平均数作为特征权重阈值
            g=int(len(sorted_weight_vecate)/2-1)
            n=int(g+1) 
            threshold_value=(sorted_weight_vecate[g]+sorted_weight_vecate[n])/2#最中间两个数的特征权重的平均值
        print(threshold_value)
        for s in range(len(sorted_weight_vecate)):#遍历特征权重向量,选择排序的特征权重向量的后半部分
            if(s>g):#当一个特征的特征权重下标大于特征权重阈值的下标
                wv=featnames[s]
                Feature_subset_list.append(wv)#将选中的特征放入特征子集列表中
        print(Feature_subset_list)#选中的特征列表
        
        for d in Feature_subset_list:#从featnames中删除选中的特征
            featnames.remove(d)
        print(featnames)#没有选中的特征列表
        
        
        #print(dataSet.__class__)
        print(dataSet)
        dataSet=pd.DataFrame(data=dataSet,columns=feat_class,copy=True)#将数组转换为数据框
        for i in featnames:#删除数据集中没有选中的特征列数据
            del(dataSet[i])
        print(dataSet)#删除了没被选中的特征列的数据集
        featnames=Feature_subset_list
        
        return dataSet,featnames
    
    展开全文
  • 文本特征选择算法的研究文本特征选择算法的研究
  • 针对大多数动态特征选择算法不能实时地根据特征重要性的变化动态优化模糊特征的问题,提出了基于特征变权的动态模糊特征选择算法.该算法利用滑动窗口分割模糊化后的数据,在第1个窗口中进行离线模糊特征选择,根据输入...
  • 特征选择算法分享

    2020-07-14 21:37:16
    特征选择算法分享 http://www.zhihuishi.com/source/1811.html添加链接描述

    特征选择算法分享
    http://www.zhihuishi.com/source/1811.html添加链接描述

    展开全文
  • 结构化多视图监督特征选择算法研究
  • 基因表达数据分类的混合特征选择算法
  • 一种有效的混合数据特征选择算法
  • 基于标记权重的多标记特征选择算法
  • 主要是关于生物医学的特征选择算法,算法内容主要是基于
  • 本文档讲述了聚类特征选择算法的相关信息,内容详细全面,非常适合初学者学习。
  • FEAST算法是特征选择算法的一种,全称叫a FEAture Selection Toolbox for C and MATLAB算法,FEAST 提供了基于共同信息的滤波特征选择算法的实现,通过特征选择,可以帮助我们筛选出有用的特征,减少模型训练时间。...
  • 不平衡数据集上的Relief特征选择算法
  • 主成分分析是一种常用的特征选择算法, 经典方法是计算各个特征之间的相关, 但是相关无法评估变量间 的非线性关系. 互信息可用于衡量两个变量间相互依赖的强弱程度, 且不局限于线性相关, 鉴于此, 提出一种基于互...
  • 基于局部子空间的多标记特征选择算法

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,370
精华内容 3,748
关键字:

特征选择算法