精华内容
下载资源
问答
  • /*关联规则Apriori算法思想: 假如有一个大小为20的样本,每个样本包含I1,I2,I3,I4,I5其中的某些属性,假如A样本为{I1,I2,I3},B样本为{I1,I2,I4}之类的,设置最小支持度为2,即选择出来的频繁项集的所有属性至少有2个...
    /*
    关联规则Apriori算法思想: 假如有一个大小为20的样本,每个样本包含I1,I2,I3,I4,I5其中的某些属性,假如A样本为{I1,I2,I3},B样本为{I1,I2,I4}之类的,设置最小支持度为2,即选择出来的频繁项集的所有属性至少有2个样本全部包含,比如频繁项集{I1,I2},此时A和B都包含,当然其他的样本也可能包含。那么这个频繁项集是符合的,那么我们可以认为I1和I2的关联性是
    比较强的。直到找到大小最大的频繁项集。
    */
    #include<cstdio> #include<iostream> #include<string> #include<vector> #include<cstring> #include<map> #include<algorithm> using namespace std; #define UINT_MAX 100 class Apriori{ public: Apriori(size_t is=0,unsigned int mv=0){ item_size=is; min_value=mv; } ~Apriori(){} void getItem(); /**求事务的频繁项**/ map<vector<string>,unsigned int> find_freitem(); /**连接两个k-1级频繁项,得到第k级频繁项**/ map<vector<string>,unsigned int> apri_gen(unsigned int K,map<vector<string>,unsigned int> K_item); /**展示频繁项集**/ void showAprioriItem(unsigned int K,map<vector<string>,unsigned int> showmap); private: map<int,vector<string> > item; /**存储所有最开始的事务及其项**/ map<vector<string>,unsigned int> K_item; /**存储频繁项集**/ size_t item_size; /**事务数**/ unsigned int min_value; /**最小支持度**/ }; void Apriori::getItem(){ int ci=item_size; for(int i=0;i<ci;i++){ string str; vector<string> temp; cout<<"请输入第"<<i+1<<"个事务的项集(123 end):"; while(cin>>str&&str!="123"){ temp.push_back(str); } sort(temp.begin(),temp.end()); pair< map<int,vector<string> >::iterator,bool> ret=item.insert(make_pair(i+1,temp)); if(!ret.second){ /**插入失败**/ --i; cout<<"你输入的元素已存在!请重新输入!"<<endl; } } cout<<"--------------运行结果如下:--------------"<<endl; } map<vector<string>,unsigned int> Apriori::find_freitem(){ unsigned int i=1; bool isEmpty=false; map<int,vector<string> >::iterator mit; for(mit=item.begin();mit!=item.end();mit++){ vector<string> vec=mit->second; if(vec.size()!=0) break; /**找到第一个非空的事务**/ } if(mit==item.end()){ isEmpty=true; cout<<"事务集为空!程序无法进行..."<<endl; map<vector<string>,unsigned int> empty; return empty; } while(1){ map<vector<string>,unsigned int> K_itemTemp=K_item; K_item=apri_gen(i++,K_item); if(K_itemTemp==K_item){ /****/ i=UINT_MAX; break; } map<vector<string>,unsigned int> pre_K_item=K_item; size_t Kitemsize=K_item.size(); if(Kitemsize!=1&&i!=1){ vector<map<vector<string>,unsigned int>::iterator> eraseVecMit; map<vector<string>,unsigned int>::iterator pre_K_item_it1=pre_K_item.begin(),pre_K_item_it2; while(pre_K_item_it1!=pre_K_item.end()){ map<vector<string>,unsigned int>::iterator mit=pre_K_item_it1; bool isExist=true; vector<string> vec1; vec1=pre_K_item_it1->first; vector<string> vec11(vec1.begin(),vec1.end()-1);/**除了最后一项**/ while(mit!=pre_K_item.end()){ vector<string> vec2; vec2=mit->first; vector<string> vec22(vec2.begin(),vec2.end()-1); if(vec11==vec22) break; /**找到第一个相等的**/ ++mit; } if(mit==pre_K_item.end()) isExist=false; /**不存在**/ if(!isExist&&pre_K_item_it1!=pre_K_item.end()) /**该项可以删除**/ eraseVecMit.push_back(pre_K_item_it1); ++pre_K_item_it1; /**继续下一个**/ } size_t eraseSetSize=eraseVecMit.size(); if(eraseSetSize==Kitemsize) break; /**频繁项集全部应该被删除,则退出**/ else{ vector<map<vector<string>,unsigned int>::iterator >::iterator currentErs=eraseVecMit.begin(); while(currentErs!=eraseVecMit.end()){ /**删除应该删除的项集**/ map<vector<string>,unsigned int>::iterator eraseMit=*currentErs; K_item.erase(eraseMit); ++currentErs; } } } else if(Kitemsize==1) break;/**只剩下一个频繁项集也退出**/ } cout<<endl; showAprioriItem(i,K_item); return K_item; } map<vector<string>,unsigned int> Apriori::apri_gen(unsigned int K,map<vector<string>,unsigned int> K_item){ if(1==K){ /**候选集C1**/ size_t c1=item_size; map<int,vector<string> >::iterator mapit=item.begin(); vector<string> vec; map<string,unsigned int> c1_itemtemp; while(mapit!=item.end()){ vector<string> temp=mapit->second; /**事务中的项目**/ vector<string>::iterator vecit=temp.begin(); while(vecit!=temp.end()){ pair<map<string,unsigned int>::iterator,bool> ret=c1_itemtemp.insert(make_pair(*vecit++,1)); if(!ret.second){ ++ret.first->second; /**该项目出现的个数加1**/ } } ++mapit; } map<string,unsigned int>::iterator item_it=c1_itemtemp.begin(); map<vector<string>,unsigned int> c1_item; while(item_it!=c1_itemtemp.end()){ vector<string> temp; if(item_it->second>=min_value){ /**大于最小支持度的才加入到1-频繁项目集**/ temp.push_back(item_it->first); c1_item.insert(make_pair(temp,item_it->second)); } ++item_it; } return c1_item; } else{ cout<<endl; showAprioriItem(K-1,K_item); /**显示(k-1)-频繁项目集**/ map<vector<string>,unsigned int>::iterator ck_item_it1=K_item.begin(),ck_item_it2; map<vector<string>,unsigned int> ck_item; while(ck_item_it1!=K_item.end()){ ck_item_it2=ck_item_it1; ++ck_item_it2; map<vector<string>,unsigned int>::iterator mit=ck_item_it2; while(mit!=K_item.end()){ vector<string> vec,vec1,vec2; vec1=ck_item_it1->first; vec2=mit->first; vector<string>::iterator vit1,vit2; vit1=vec1.begin(); vit2=vec2.begin(); while(vit1<vec1.end()&&vit2<vec2.end()){ string str1=*vit1; string str2=*vit2; ++vit1; ++vit2; if(K==2||str1==str2){ if(vit1!=vec1.end()&&vit2!=vec2.end()){ vec.push_back(str1); } } else break; } if(vit1==vec1.end()&&vit2==vec2.end()){ /**前K-1项相同**/ --vit1; --vit2; string str1=*vit1; string str2=*vit2; if(str1>str2){ /**再插入**/ vec.push_back(str2); vec.push_back(str1); } else{ vec.push_back(str1); vec.push_back(str2); } map<int,vector<string> >::iterator base_item=item.begin(); unsigned int Acount=0; while(base_item!=item.end()){ unsigned int count=0,mincount=UINT_MAX; vector<string> vv=base_item->second; vector<string>::iterator vecit,bvit; for(vecit=vec.begin();vecit<vec.end();vecit++){ string t=*vecit; count=0; for(bvit=vv.begin();bvit<vv.end();bvit++){ if(t==*bvit) count++; } mincount=(count<mincount?count:mincount); } if(mincount>=1&&mincount!=UINT_MAX) /**该项集是该事务的子集**/ Acount+=mincount; ++base_item; } if(Acount>=min_value&&Acount!=0){ /**大于等于最小支持度**/ sort(vec.begin(),vec.end()); pair<map<vector<string>,unsigned int>::iterator,bool> ret=ck_item.insert(make_pair(vec,Acount)); if(!ret.second){ ret.first->second+=Acount; } } } ++mit; } ++ck_item_it1; } if(ck_item.empty()) return K_item; else return ck_item; } } void Apriori::showAprioriItem(unsigned int K,map<vector<string>,unsigned int> showmap){ map<vector<string>,unsigned int>::iterator showit=showmap.begin(); if(K!=UINT_MAX) cout<<endl<<""<<K<<" 级频繁项集为:"<<endl; else cout<<"最终的频繁项集为:"<<endl; cout<<"项 集"<<" \t "<<"频率"<<endl; while(showit!=showmap.end()){ vector<string> vec=showit->first; vector<string>::iterator vecit=vec.begin(); cout<<"{"; while(vecit!=vec.end()){ cout<<*vecit<<" "; ++vecit; } cout<<"}"<<" \t "; cout<<showit->second<<endl; ++showit; } } unsigned int parseNumber(const char *str){ if(str==NULL) return 0; else{ unsigned int num=0; size_t len=strlen(str); for(size_t i=0;i<len;i++){ num*=10; if(str[i]>='0'&&str[i]<='9') num+=str[i]-'0'; else return 0; } return num; } } int main(){ /* unsigned int itemsize=0; unsigned int min; do{ cout<<"请输入事务数:"; char *str=new char; cin>>str; itemsize=parseNumber(str); //事务数 if(itemsize==0){ cout<<"请输入大于0正整数!"<<endl; } }while(itemsize==0); do{ cout<<"请输入最小阈值:"; char *str=new char; cin>>str; min=parseNumber(str); //最小支持度 if(min==0){ cout<<"请输入大于0正整数!"<<endl; } }while(min==0); Apriori a(itemsize,min); a.getItem(); map<vector<string>,unsigned int> AprioriMap=a.find_freitem(); //找到频繁项目集 a.showAprioriItem(UINT_MAX,AprioriMap); */ return 0; }

     

    转载于:https://www.cnblogs.com/wust-ouyangli/p/6642078.html

    展开全文
  • Apriori算法时经典的挖掘频繁项集的算法,第一次实现了再大数据集上可行的关联规则提取,其核心思想是通过连接产生候选项与其支持度,然后通过剪枝生成频繁项集。 1.关联规则的一般方式 项...

    以超市销售数据为例子,提取关联规则的最大困难在于当存在很多商品时,可能的商品的组合的数目会达到一种令人望而却步的程度。因而各种关联规则分析的算法从不同方面入手,以减少可能的搜索空间的大小以及减少扫描数据的次数。Apriori算法时经典的挖掘频繁项集的算法,第一次实现了再大数据集上可行的关联规则提取,其核心思想是通过连接产生候选项与其支持度,然后通过剪枝生成频繁项集。

    1.关联规则的一般方式

    项集A,B同时发生的概率称为关联规则的支持度 Support(A=>B) = P(AUB)

    项集合A发生,则项集B发生的概率为关联规则的置信度 Confidence(A=>B) = P(B|A)

    2.最小支持度与最小置信度

    最小支持度使用户或专家定义的衡量支持度的一个阈值,表示项目集在统计意义上最低的重要性;最小置信度是用户或专家定义的衡量置信度的一个阈值,表示关联规则是的最低可靠性。同时满足最小支持度阈值和最小置信度和最小置信阈值的规则称强规则。

    3.项集

    项集是项的集合,包含K个项的集合,如集合{牛奶,麦片,糖}是一个3项集合。项集出现的频率是所有包含项集的事务计数,又称作绝对支持度或支持度计数。如果项集I的相对支持度满足预定义的最小支持度阈值,则I是频繁项集。

    4.支持度计数

    项集A的支持度计数是事务数据集中包含项集A的事务个数,简称为项集的频率或者计数。

    已知项集的支持度计数,则规则A=>B的支持度和置信度很容易从所有事务计数,项集A和项集AUB的支持度计数推出:

    也就是说,一旦得到所有事务个数,A,B和A并B的支持度计数,就可以导出对应的关联规则A=>B和B=>A,并可以检查该规则是否是强规则。

    5.Apriori算法:使用候选项产生频繁项集

    Apriori算法的主要思想是找出存在于事务数据集中的最大的频繁项集,在利用得到的最大频繁项集与预先设定的最小置信度阈值生成强关联规则。

    (1)Apriori性质

    频繁项集的所有非空子集也必须是频繁项集。根据该性质可以得出:向不是频繁项集I的项集中添加事务A,新的项集I U A一定也不是频繁项集。

    (2)Apriori算法实现的两个过程如下

    1)找出所有频繁项集。对给定的最小支持度阈值,分别对1项候选集C1,剔除小于该阈值的项集得到1项频繁集L1;下一步由L1自身连接产生2项候选集C2,保留C2中满足约束条件的项集得到2项频繁集,记为L2;再下一步由L2与L3连接产生3项候选集C3,保留C2中满足约束条件对的项集得到3项频繁数据集,记为L3......这样循环下去,得到最大频繁项集Lk。

    剪枝步:

    剪枝步紧接着连接步,在产生候选项Ck的过程中起到减少搜索空间的目的。由于Ck是Lk-1 与 L1连接产生的,根据Apriori的性质频繁项集的所有非空子集也必须是频繁项集,所以不满足该性质的项集不会存在于Ck中,该过程就是剪枝。

    2)由频繁项集产生强关联规则:由过程1)可知超过预定的最小支持阈值的项集已被剔除,如果剩下这些规则又满足了预定最小置信阈值,那么就产生了强关联规则。

    6.python代码实现

    数据集:

    在这里a,b,c,d,e可以看做是不同的商品,每一行代表客户所购买的商品的信息。

    cal_apiori.py:

    import pandas as pd
    import os
    from apriori import *
    
    basedir = os.path.dirname(__file__)
    inputfile = os.path.join(basedir, './data/menu_orders.xls')
    outputfile = os.path.join(basedir, './data/apiori_rules.xls')
    
    data = pd.read_excel(inputfile, header = None) # 读取数据
    
    print(u'\n转换 原始数据至0-1矩阵....')
    ct = lambda x : pd.Series(1, index=x[pd.notnull(x)]) # 转换0-1矩阵的过渡函数
    b =  map(ct, data.as_matrix()) # 用map方式执行
    
    
    data = pd.DataFrame(list(b)).fillna(0) # 实现矩阵转换,空值用0填充
    print(u'\n转换完毕.')
    del b # 删除中间变量,节省内存
     
    support = 0.2 # 最小支持度
    confidence = 0.5 # 最小置信度
    ms = "---" # 连接符,默认'--',用来区分不同的元素,如A--B,许可要保证原始表格中不含有该字符
    
    print(data, support, confidence)
    
    """
        data的数据结构:
                a    c    e    b    d
            0  1.0  1.0  1.0  0.0  0.0
            1  0.0  0.0  0.0  1.0  1.0
            2  0.0  1.0  0.0  1.0  0.0
            3  1.0  1.0  0.0  1.0  1.0
            4  1.0  0.0  0.0  1.0  0.0
            5  0.0  1.0  0.0  1.0  0.0
            6  1.0  0.0  0.0  1.0  0.0
            7  1.0  1.0  1.0  1.0  0.0
            8  1.0  1.0  0.0  1.0  0.0
        support: 最小支持度阈值
        confidence: 最小置信度阈值
        ms: 连接符,用来区分不同的元素,如A---B,需要保证原始表格中不含有这种字符
    """
    find_rule(data, support, confidence, ms).to_excel(outputfile) # 保存结果

    apriori.py

    import pandas as pd
    
    
    def connect_string(x, ms):
        """
        定义连接函数,用于实现从L_{k-1} 到 C_k 的连接
        """
        x = list(map(lambda i: sorted(i.split(ms)), x)) # 频繁项集的个数
        print(x)
        l = len(x[0]) # 每个平凡项集合,属性的个数
        r = []
        for i in range(len(x)):
            for j in range(i, len(x)): # 这里可以看成是两个个二维表连接
                # 在进行连接的操作的时候,首先对其中的属性作了排序,所以这里只需要判断前面(l-1)个【多个元素比较】是否相同,如果相同&&最后一个元素不相同=>则进行连接操作
                if x[i][:l - 1] == x[j][:l - 1] and x[i][l - 1] != x[j][l - 1]:
                    r.append(x[i][:l - 1] + sorted([x[j][l - 1], x[i][l - 1]])) # add:[[前l-1个元素]+sorted([原来的第l个元素+新增加的元素])]
        return r
    
    
    def find_rule(d, support, confidence, ms=u'--'):
        """
        寻找关联规则的函数
        """
        result = pd.DataFrame(index=['support', 'confidence']) # 定义输出结果
        support_series = 1.0 * d.sum() / len(d) # 支持度序列(求每一列的的支持度)
        column = list(support_series[support_series > support].index) # 初步支持度筛选(大于最小支持度),同时转化为list列表
        k = 0
    
        while len(column) > 1:
            k = k + 1 # 累加第几次
            print(u'\n正在进行第%s次搜索...' % k)
    
            column = connect_string(column, ms) # 使用连接函数进行连接(column:大于最小支持度的列的集合,ms:切割字符串)
    
            print(u'数目: %s...' % len(column))
    
            sf = lambda i: d[i].prod(axis = 1, numeric_only = True) # 新一批支持度的计算函数
    
            # 创建连接数据
            d_2 = pd.DataFrame(list(map(sf, column)), index=[ms.join(i) for i in column]).T 
            
            support_series_2 = 1.0 * d_2[[ms.join(i) for i in column]].sum() / len(d) # 计算连接后的支持度
            column = list(support_series_2[support_series_2 > support].index) # 新一轮支持度筛选
            support_series = support_series.append(support_series_2)
            column2 = []
    
            for i in column: # 遍历可能的推理, 如{A, B, C} 究竟是A+B-->C 还是 B+C-->A 还是C+A-->B
                i = i.split(ms)
                for j in range(len(i)):
                    column2.append(i[:j] + i[j+1:] + i[j: j+1]) # 这三个位置分别为: (前j个元素不包括) + (后j+1个元素) --> (中间第j个元素)
            
            confidence_series = pd.Series(index=[ms.join(i) for i in column2]) # 定义置信度序列
    
            for i in column2: # 计算置信度序列 
                # 置信度 = support(a&b) / support(a) 其中这里a代表前件, b代表后件
                confidence_series[ms.join(i)] = support_series[ms.join(sorted(i))] / support_series[ms.join(i[:len(i) - 1])]
    
            for i in confidence_series[confidence_series > confidence].index: # 置信度筛选(筛选出置信度大于最小置信度阈值)
                result[i] = 0.0 # 清空
                result[i]['confidence'] = confidence_series[i] 
                result[i]['support'] = support_series[ms.join(sorted(i.split(ms)))] 
            
        result = result.T.sort_values(['confidence', 'support'], ascending = False) # 结果整理输出
        print(u'\n 结果为:')
        print(result)
    
        return result

    运行结果:

    展开全文
  • Apriori算法是第一个关联规则挖掘算法,也是最经典的算法。它利用逐层搜索的迭代方法找出数据库中项集的关系,以形成规则,其过程由连接(类矩阵运算)与剪枝(去掉那些没必要的中间结果)组成。该算法中项集的概念...


    Apriori算法是第一个关联规则挖掘算法,也是最经典的算法。它利用逐层搜索的迭代方法找出数据库中项集的关系,以形成规则,其过程由连接(类矩阵运算)与剪枝(去掉那些没必要的中间结果)组成。该算法中项集的概念即为项的集合。包含K个项的集合为k项集。项集出现的频率是包含项集的事务数,称为项集的频率。如果某项集满足最小支持度,则称它为频繁项集

    • 频繁项集:找出频繁一起出现的物品集的集合
    • 支持度:一个项集的支持度被定义为数据集中包含该项集的记录所占的比例;
      支持度 = (包含物品A的记录数量) / (总的记录数量
      在这里插入图片描述
    • 置信度体现了一个数据出现后,另一个数据出现的概率,或者说数据的条件概率。
      在这里插入图片描述
      图片来源https://www.cnblogs.com/pinard/p/6293298.html

    关联规则基本思想

    1. 找出所有频繁项集:找出支持度大于最小支持度的项集,即频繁项集
    2. 由频繁项集产生关联规则:这些规则必须满足最小支持度和最小可信度
    3. 算法核心思想
      频繁项集的非空子集一定也是频繁的

    算法基本过程

    • 算法命名源于算法使用了频繁项集性质的先验知识
    • 算法的基本过程:
      1. 生成候选集:找出候选集,即有可能成为频繁集的项集
      2. 生成频繁项集:生成通过数据库扫描筛选出满足条件的候选集形成又一层频繁集
        (频繁项集的子集也一定是频繁项集)例如:如果{A,B}是频繁集,则{A}{B}也一定是频繁集
      3. 生成关联规则:用得到的频繁集生成强关联规则。
    • Apriori算法中候选集生成步骤:
      1. 自连接Lk-1
        在这里插入图片描述
      2. 修剪
        . 在这里插入图片描述

    算法总结

    Aprior算法是一个很经典的频繁项集的挖掘算法,很多算法都是基于Aprior算法而产生的,包括FP-Tree,GSP, CBA等。这些算法利用了Aprior算法的思想,但是对算法做了改进,数据挖掘效率更好一些,因此现在一般很少直接用Aprior算法来挖掘数据了,但是理解Aprior算法是理解其它Aprior类算法的前提,同时算法本身也不复杂,因此值得好好研究一番。

    展开全文
  • 是什么:apriori算法是第一个关联规则挖掘算法,利用逐层搜索的迭代方法找出数据库中的项集(项的集合)的关系,以形成规则,其过程由连接(类矩阵运算)与剪枝(去掉没必要的中间结果)组成。是一种挖掘关联规则的...

    4ecccdd25aea766371806f5130acb5dd.png

    是什么:

    apriori算法是第一个关联规则挖掘算法,利用逐层搜索的迭代方法找出数据库中的项集(项的集合)的关系,以形成规则,其过程由连接(类矩阵运算)与剪枝(去掉没必要的中间结果)组成。是一种挖掘关联规则的频繁项集算法,一种最有影响的挖掘布尔关联规则频繁项集的算法。核心思想是通过候选集生成和情节的向下封闭检测两个阶段来挖掘频繁项集。

    关联规则挖掘,在最早提出时,是为了发现交易数据库中不同商品之间的联系规则。刻画顾客购买行为模型,指导商家科学地进行进货,库存以及货架设计等。

    改进的算法有:并行关联规则挖掘Parallel Association Rule Mining,以及数量关联规则挖掘Quantitive Association Rule Mining。提高挖掘规则算法的效率,适应性,可用性以及应用推荐。

    频繁项集的评估标准:支持度,置信度,提升度三个方面。

    应用领域:在商业,网络安全广泛使用。通过对数据的关联性进行了分析和挖掘,挖掘出的这些信息在决策制定过程中具有重要的参考价值。

    在消费市场价格分析中,能够很快求出各种产品之间的价格关系和它们之间的影响,可以瞄准目标客户,采用个人股票行市,最新细心,特殊的市场推广活动或其他的一些特殊信息手段,减少广告预算和增加收入。预测客户的消费习惯。

    相关概念:

    支持度:a和b同时出现的概率,或者是几个关联的数据在数据集中出现的次数占总数据集的比重。

    置信度:a和b同时出现的概率占a出现概率的比值,或者是一个数据出现后,另一个数据出现的概率,或者说数据的条件概率。

    提升度:表示含有y的条件下, 同时含有x的概率,与x总体发生的概率之比。提升度体现了x和y之间的关联关系,提升度大于1则xy是有效的强关联规则,小于等于1则是无效的强关联规则。

    频繁项集:频繁项集挖掘可以告诉我们在数据集中经常一起出现的变量,为可能的决策提供一些支持。频繁项集挖掘是关联规则,相关性分析,因果分析,序列项集,局部周期性等许多数据挖掘任务的基础。应用在购物车分析,网页预取,交叉购物,个性化网站等。

    强关联规则:满足最小支持度和最小置信度的关联规则。

    相类似的算法:

    PrefixSpan

    CBA

    FP-Tree

    GSP


    FP-growth 算法

    属于关联分析算法,采取的分治策略如下:将提供频繁项集的数据库压缩到一颗频繁模式树FP-Tree ,保留项集关联信息。在算法中使用了一种称为频繁模式树的数据结构,fp-tree是一种特殊的前缀树,有频繁项头表和项前缀树构成。用于改善Apriori算法,加快整个挖掘过程。

    相关概念:

    FP-Tree :将事务数据表中的各个事务数据项按照支持度排序后,把每个事务中的数据项按降序一次插入到一颗以null为根节点的树中,同时在每个节点处记录该节点出现的支持度。

    条件模式基:包含FP-Tree中与后缀模式一起出现的前缀路径的集合。

    条件树:将条件模式基按照FP-Tree的构造原则形成的一个新的FP-Tree。

    基本思路:不断的迭代FP-Tree的构造和投影过程。

    算法描述:

    1. 对于每个频繁项,构造ta 的条件投影数据库和投影FP-Tree
    2. 对每个新构建的FP-Tree重复这个过程,知道构造新的FP-Tree为空,或者只包含一条路径。
    3. 当构造的FP-Tree为空时,其前缀即为频繁模式,当只包含一条路径时,通过枚举所以可能组合并与此树的前缀连接即可得到频繁模式。

    该算法的流程为:首先构造FP树,然后利用ta来挖掘频繁项集。在构造fp树时,需要对数据集扫描两次,一次为用来统计频率(频次和频率),第二次扫描至考虑频繁项集。

    缺点:

    1. 对数据库扫描数次过多
    2. apriori会产生大量的中间项集
    3. 采用唯一支持度
    4. 算法的适应面窄

    参考:

    https://bainingchao.github.io/2018/09/27/%E4%B8%80%E6%AD%A5%E6%AD%A5%E6%95%99%E4%BD%A0%E8%BD%BB%E6%9D%BE%E5%AD%A6%E5%85%B3%E8%81%94%E8%A7%84%E5%88%99Apriori%E7%AE%97%E6%B3%95/bainingchao.github.io数据挖掘十大算法--Apriori算法_小硒---代码无疆-CSDN博客blog.csdn.net
    1cf6bfa0d000b1f9a76bee96b377acb2.png
    Suranyi:Apriori 算法简介及 python3实现zhuanlan.zhihu.com
    f8496bcd9326acb6a12d4a9ec4c4d14b.png
    机器学习(九)-FP-growth算法 - Yabea - 博客园www.cnblogs.com
    e3b157c68df949721de1c5351194aab7.png
    FP Tree算法原理总结 - 刘建平Pinard - 博客园www.cnblogs.com
    60af8717c45a7da5b550a52e4208f22f.png
    FP-growth算法--原理_jmhIcoding-CSDN博客blog.csdn.net
    1cf6bfa0d000b1f9a76bee96b377acb2.png
    Superman:FP-Growth算法简介zhuanlan.zhihu.com
    zhihu-card-default.svg
    展开全文
  • 关联规则Apriori算法

    2020-06-08 21:33:09
    2.1 Apriori算法思想 2.2 Apriori算法流程 一、关联规则 关联规则分析(Association Rule Analysis)是为了发掘数据背后的关联关系而诞生的。 我们可以定义一个关联规则: 其中,X,Y分别表示两个互斥事件,Y...
  • 关联规则association rule mining是众多“规则类”数据挖掘方法中的一种,对于关联规则的基本理论(假定读者已经了解)不在这里详细叙述,... Apriori算法的主要思想:  1、根据Apriori性质“频繁项集的子集一定是
  • Apriori算法是一种挖掘关联规则的频繁项集算法,其核心思想是通过候选集生成和情节的向下封闭检测两个阶段来挖掘频繁项集。 关于这个算法有一个非常有名的故事:"尿布和啤酒"。故事是这样的:美国的妇女们...
  • 文章目录关联规则挖掘过程Apriori算法1. Apriori算法的基本思想2. Apriori算法产生频繁项集的过程3. Apriori算法的主要步骤4. 举例及代码实现 关联规则挖掘过程 关联规则挖掘问题可以分解为以下两个子问题 找频繁...
  • 关联规则-Apriori算法

    千次阅读 2017-05-14 15:24:39
    Apriori核心算法思想简要描述如下: 该算法中有两个关键步骤为连接步和剪枝步。 1)连接步:为找出Lk(频繁k项集),通过Lk-1与自身连接,产生候选k项集,该候选k项集,该候选集记作Ck;其中Lk-1的元素是可连接的。 ...
  • 关联规则的一个重要算法,使用基于支持度的剪枝技术,从而控制候选项集的指数级别的增长 大体流程先知 1.设定最小支持度和最小置信度 2.扫描数据集,统计每个项的支持度计数,得到候选1项集 3.计算每个项的支持度...
  • 关联——Apriori算法详解

    千次阅读 2018-05-28 11:02:31
    一、Apriori算法简介: Apriori算法是一种挖掘关联规则的频繁项集算法,其核心思想是通过候选集生成和情节的向下封闭检测两个阶段来挖掘频繁项集。 Apriori(先验的,推测的)算法应用广泛,可用于消费市场价格分析...
  • 是什么:apriori算法是第一个关联规则挖掘算法,利用逐层搜索的迭代方法找出数据库中的项集(项的集合)的关系,以形成规则,其过程由连接(类矩阵运算)与剪枝(去掉没必要的中间结果)组成。是一种挖掘关联规则的...
  • 是什么:apriori算法是第一个关联规则挖掘算法,利用逐层搜索的迭代方法找出数据库中的项集(项的集合)的关系,以形成规则,其过程由连接(类矩阵运算)与剪枝(去掉没必要的中间结果)组成。是一种挖掘关联规则的频繁项...
  • Apriori 算法 理论

    千次阅读 2016-03-14 15:16:24
    关联规则的基本模型—规则 关联规则的基本模型—置信度 关联规则的基本模型—支持度 关联规则基本概念 ...Apriori算法思想总结 Apriori算法代码 由L(k-1)生成候选集Ck 从频繁项集中挖掘关联规则
  • 关联规则挖掘和序列模式挖掘的Apriori算法,介绍了关联规则和序列模式的基本概念,Apriori算法思想和伪代码,挖掘频繁项集的例子。
  • 一,Apriori算法的基本思想:
  • 关联规则挖掘的算法——Apriori算法

    千次阅读 2007-10-07 20:49:00
    Agrawal等于1993年[1]首先提出了挖掘顾客交易数据库中项集间的关联规则问题,其核心方法是基于频集理论的递推方法。以后诸多的研究人员对关联规则的挖掘问题进行了大量的研究。...一、Apriori算法基本原理Agrawa
  • Apriori关联规则算法

    2012-05-24 19:21:05
    Apriori关联规则算法源代码目前已提出了许多挖掘关联规则的算法,其中最 为经典的是Ap riori算法[ 123 ] ,算法思想是使用逐层搜索的迭代方法。算法主要包括三个步骤:连接步、剪枝步和扫描数据库。而本文通过对剪枝步...
  • 关联规则----Apriori算法以及代码实现

    千次阅读 2020-05-13 16:18:34
    关联规则概述关联规则中的几个概念频繁项集和强规则误区Apriori算法介绍Apriori核心思想Apriori流程算法步骤问题的关键---如何由频繁项集生成候选集详细例子生成规则 概述 数据挖掘是指以某种方式分析数据源,从中...
  • Apriori算法是一种挖掘关联规则的频繁项集算法,核心思想是通过候选项生成和情节的向下封闭检测两个阶段来挖掘频繁项集。 很多挖掘算法是在Apriori算法的基础上进行改进的,比如基于散列(Hash)的方法,基于数据...
  • [Python] 关联规则算法 Apriori

    千次阅读 2018-06-18 23:58:47
    关联规则最常用也是最经典的挖掘频繁项集的算法,其核心思想是通过连接产生候选项及其支持度然后通过剪枝生成频繁项集。 关联规则的一般形式 (1)支持度 项集A、B同事发生的概率称为关联规则的支持度(相对...
  • 主要思想是找出存在于事务数据集中的最大的频繁项集,再利用得到的最大频繁项集和预先设定的最小置信度阈值生成强关联规则 1. 重要概念 (1)关联规则支持度和置信度 项集A、B同时发生的概率称为关联规则的支持度 ...
  • Apriori 核心思想:通过连接产生候选项与其支持度,然后通过剪枝生成频繁项集。 关键概念: 项集:项的集合。... 最小置信度:关联规则的最低可靠性。 同时满足最小支持度阈值和最小置信度阈值的规则称作...
  • 文章目录(一)关联规则挖掘(二)Apriori关联规则挖掘算法的基本思想(三)问题描述(四)Matlab实现Apriori挖掘算法,提取关联规则 (一)关联规则挖掘 关联规则挖掘(Association rule mining)是数据挖掘中最...
  • 标签:目的seaborn子集阶段频繁项集使用输出相关图片Apriori算法的简介Apriori算法:使用候选项集找频繁项集Apriori算法是一种最有影响的挖掘布尔关联规则频繁项集的算法。其核心是基于两阶段频集思想的递推算法。该...
  • 数据挖掘笔记(5)-关联规则算法Apriori

    千次阅读 2019-01-22 11:12:10
    2、关联规则算法Apriori Apriori是最常用也是最经典的挖掘频繁项集的算法,其核心思想是通过连接产生候选项及其支持度,然后通过剪枝生成频繁项集。 (1)项集 项集是项的集合,包含k个项的就是k项集,如{牛奶,面...
  • Apriori算法基本思想

    千次阅读 2009-11-18 19:44:00
    *****点击此处显示Apriori代码实现*****Apriori算法是一个挖掘关联规则的算法,是Agrawal等设计的一个基本算法,这是一个采用两阶段挖掘的思想,并且基于多次扫描事务数据库来执行的。Apriori算法的设计可以分解为两...

空空如也

空空如也

1 2 3 4 5 ... 12
收藏数 229
精华内容 91
关键字:

关联规则apriori算法思想