Ⅰ apriori里python調用了哪些庫有哪些關鍵函數
第一，apriori只是一種挖掘演算法，沒有特定的只能用pyton或者某一種語言；
apriori演算法的邏輯流程
首先找出所有的頻集，這些項集出現的頻繁性至少和預定義的最小支持度一樣。然後由頻集產生強關聯規則，這些規則必須滿足最小支持度和最小可信度。然後使用第1步找到的頻集產生期望的規則，產生只包含集合的項的所有規則，其中每一條規則的右部只有一項，這里採用的是中規則的定義。一旦這些規則被生成，那麼只有那些大於用戶給定的最小可信度的規則才被留下來。為了生成所有頻集，使用了遞歸的方法。
（1） L1 = find_frequent_1-itemsets(D);
（2） for (k=2;Lk-1 ≠Φ ;k++) {
（3） Ck = apriori_gen(Lk-1 ,min_sup);
（4） for each transaction t ∈D{//scan D for counts
（5） Ct = subset(Ck,t);//get the subsets of t that are candidates
（6） for each candidate c ∈ Ct
（7） c.count++;
（8）}
（9） Lk ={c ∈ Ck|c.count≥min_sup}
（10）}
（11） return L= ∪ k Lk;
可能產生大量的候選集,以及可能需要重復掃描資料庫，是Apriori演算法的兩大缺點。
從邏輯上看，會用到的庫：
字元處理的庫
資料庫處理的庫
集合運算的庫
概率期望運算的庫（入numpy）
Ⅱ 如何實現apriori演算法
java">importjava.util.HashMap;
importjava.util.HashSet;
importjava.util.Iterator;
importjava.util.Map;
importjava.util.Set;
importjava.util.TreeMap;
/**
*<B>關聯規則挖掘：Apriori演算法</B>
*
*<P>按照Apriori演算法的基本思想來實現
*
*@authorking
*@since2013/06/27
*
*/
publicclassApriori{
privateMap<Integer,Set<String>>txDatabase;//事務資料庫
privateFloatminSup;//最小支持度
privateFloatminConf;//最小置信度
privateIntegertxDatabaseCount;//事務資料庫中的事務數
privateMap<Integer,Set<Set<String>>>freqItemSet;//頻繁項集集合
privateMap<Set<String>,Set<Set<String>>>assiciationRules;//頻繁關聯規則集合
publicApriori(
Map<Integer,Set<String>>txDatabase,
FloatminSup,
FloatminConf){
this.txDatabase=txDatabase;
this.minSup=minSup;
this.minConf=minConf;
this.txDatabaseCount=this.txDatabase.size();
freqItemSet=newTreeMap<Integer,Set<Set<String>>>();
assiciationRules=newHashMap<Set<String>,Set<Set<String>>>();
}
/**
*掃描事務資料庫，計算頻繁1-項集
*@return
*/
publicMap<Set<String>,Float>getFreq1ItemSet(){
Map<Set<String>,Float>freq1ItemSetMap=newHashMap<Set<String>,Float>();
Map<Set<String>,Integer>candFreq1ItemSet=this.getCandFreq1ItemSet();
Iterator<Map.Entry<Set<String>,Integer>>it=candFreq1ItemSet.entrySet().iterator();
while(it.hasNext()){
Map.Entry<Set<String>,Integer>entry=it.next();
//計算支持度
Floatsupported=newFloat(entry.getValue().toString())/newFloat(txDatabaseCount);
if(supported>=minSup){
freq1ItemSetMap.put(entry.getKey(),supported);
}
}
returnfreq1ItemSetMap;
}
/**
*計算候選頻繁1-項集
*@return
*/
publicMap<Set<String>,Integer>getCandFreq1ItemSet(){
Map<Set<String>,Integer>candFreq1ItemSetMap=newHashMap<Set<String>,Integer>();
Iterator<Map.Entry<Integer,Set<String>>>it=txDatabase.entrySet().iterator();
//統計支持數，生成候選頻繁1-項集
while(it.hasNext()){
Map.Entry<Integer,Set<String>>entry=it.next();
Set<String>itemSet=entry.getValue();
for(Stringitem:itemSet){
Set<String>key=newHashSet<String>();
key.add(item.trim());
if(!candFreq1ItemSetMap.containsKey(key)){
Integervalue=1;
candFreq1ItemSetMap.put(key,value);
}
else{
Integervalue=1+candFreq1ItemSetMap.get(key);
candFreq1ItemSetMap.put(key,value);
}
}
}
returncandFreq1ItemSetMap;
}
/**
*根據頻繁(k-1)-項集計算候選頻繁k-項集
*
*@paramm其中m=k-1
*@paramfreqMItemSet頻繁(k-1)-項集
*@return
*/
publicSet<Set<String>>aprioriGen(intm,Set<Set<String>>freqMItemSet){
Set<Set<String>>candFreqKItemSet=newHashSet<Set<String>>();
Iterator<Set<String>>it=freqMItemSet.iterator();
Set<String>originalItemSet=null;
while(it.hasNext()){
originalItemSet=it.next();
Iterator<Set<String>>itr=this.getIterator(originalItemSet,freqMItemSet);
while(itr.hasNext()){
Set<String>identicalSet=newHashSet<String>();//兩個項集相同元素的集合(集合的交運算)
identicalSet.addAll(originalItemSet);
Set<String>set=itr.next();
identicalSet.retainAll(set);//identicalSet中剩下的元素是identicalSet與set集合中公有的元素
if(identicalSet.size()==m-1){//(k-1)-項集中k-2個相同
Set<String>differentSet=newHashSet<String>();//兩個項集不同元素的集合(集合的差運算)
differentSet.addAll(originalItemSet);
differentSet.removeAll(set);//因為有k-2個相同，則differentSet中一定剩下一個元素，即differentSet大小為1
differentSet.addAll(set);//構造候選k-項集的一個元素(set大小為k-1,differentSet大小為k)
if(!this.has_infrequent_subset(differentSet,freqMItemSet))
candFreqKItemSet.add(differentSet);//加入候選k-項集集合
}
}
}
returncandFreqKItemSet;
}
/**
*使用先驗知識，剪枝。若候選k項集中存在k-1項子集不是頻繁k-1項集，則刪除該候選k項集
*@paramcandKItemSet
*@paramfreqMItemSet
*@return
*/
privatebooleanhas_infrequent_subset(Set<String>candKItemSet,Set<Set<String>>freqMItemSet){
Set<String>tempSet=newHashSet<String>();
tempSet.addAll(candKItemSet);
Iterator<String>itItem=candKItemSet.iterator();
while(itItem.hasNext()){
Stringitem=itItem.next();
tempSet.remove(item);//該候選去掉一項後變為k-1項集
if(!freqMItemSet.contains(tempSet))//判斷k-1項集是否是頻繁項集
returntrue;
tempSet.add(item);//恢復
}
returnfalse;
}
/**
*根據一個頻繁k-項集的元素(集合)，獲取到頻繁k-項集的從該元素開始的迭代器實例
*@paramitemSet
*@paramfreqKItemSet頻繁k-項集
*@return
*/
privateIterator<Set<String>>getIterator(Set<String>itemSet,Set<Set<String>>freqKItemSet){
Iterator<Set<String>>it=freqKItemSet.iterator();
while(it.hasNext()){
if(itemSet.equals(it.next())){
break;
}
}
returnit;
}
/**
*根據頻繁(k-1)-項集，調用aprioriGen方法，計算頻繁k-項集
*
*@paramk
*@paramfreqMItemSet頻繁(k-1)-項集
*@return
*/
publicMap<Set<String>,Float>getFreqKItemSet(intk,Set<Set<String>>freqMItemSet){
Map<Set<String>,Integer>candFreqKItemSetMap=newHashMap<Set<String>,Integer>();
//調用aprioriGen方法，得到候選頻繁k-項集
Set<Set<String>>candFreqKItemSet=this.aprioriGen(k-1,freqMItemSet);
//掃描事務資料庫
Iterator<Map.Entry<Integer,Set<String>>>it=txDatabase.entrySet().iterator();
//統計支持數
while(it.hasNext()){
Map.Entry<Integer,Set<String>>entry=it.next();
Iterator<Set<String>>kit=candFreqKItemSet.iterator();
while(kit.hasNext()){
Set<String>kSet=kit.next();
Set<String>set=newHashSet<String>();
set.addAll(kSet);
set.removeAll(entry.getValue());//候選頻繁k-項集與事務資料庫中元素做差運算
if(set.isEmpty()){//如果拷貝set為空，支持數加1
if(candFreqKItemSetMap.get(kSet)==null){
Integervalue=1;
candFreqKItemSetMap.put(kSet,value);
}
else{
Integervalue=1+candFreqKItemSetMap.get(kSet);
candFreqKItemSetMap.put(kSet,value);
}
}
}
}
Ⅲ 請問你有用maprece實現Apriori演算法的代碼嗎
matlab實現apriori演算法源代碼 一、實驗目的 通過實驗，加深數據挖掘中一個重要方法——關聯分析的認識，其經典演算法為apriori演算法，了解影響apriori演算法性能的因素，掌握基於apriori演算法理論的關聯分析的原理和方法。 二、實驗內容 對一數據集用apriori演算法做關聯分析，用matlab實現。 三、方法手段 關聯規則挖掘的一個典型例子是購物籃分析。市場分析員要從大量的數據中發現顧客放入其購物籃中的不同商品之間的關系。如果顧客買牛奶，他也購買麵包的可能性有多大？ 什麼商品組或集合顧客多半會在一次購物時同時購買？例如，買牛奶的顧客有80%也同時買麵包，或買鐵錘的顧客中有70%的人同時也買鐵釘，這就是從購物籃數據中提取的關聯規則。分析結果可以幫助經理設計不同的商店布局。一種策略是：經常一塊購買的商品可以放近一些，以便進一步刺激這些商品一起銷售，例如，如果顧客購買計算機又傾向於同時購買財務軟體，那麼將硬體擺放離軟體陳列近一點，可能有助於增加兩者的銷售。另一種策略是：將硬體和軟體放在商店的兩端，可能誘發購買這些商品的顧客一路挑選其他商品。 關聯規則是描述資料庫中數據項之間存在的潛在關系的規則,形式為 1212 ......mnAAABBB,其中(1,2...,)iAim,(1,2...,)jAjn是資料庫中的數據項.數據項之間的關聯規則即根據一個事務中某些項的出現,可推導出另一些項在同一事務中也出現。 四、Apriori演算法 1.演算法描述 Apriori演算法的第一步是簡單統計所有含一個元素的項集出現的頻率,來決定最大的一維項目集。在第k步,分兩個階段,首先用一函數sc_candidate(候選),通過第(k-1)步中生成的最大項目集Lk-1來生成侯選項目集Ck。然後搜索資料庫計算侯選項目集Ck的支持度. 為了更快速地計算Ck中項目的支持度, 文中使用函數count_support計算支持度。 Apriori演算法描述如下： (1) C1={candidate1-itemsets}; (2) L1={c∈C1|c.count≥minsupport}; (3) for(k=2,Lk-1≠Φ,k++) //直到不能再生成最大項目集為止 (4) Ck=sc_candidate(Lk-1); //生成含k個元素的侯選項目集 (5) for all transactions t∈D //辦理處理 (6) Ct=count_support(Ck,t); //包含在事務t中的侯選項目集 (7) for all candidates c∈Ct (8) c.count=c.count+1; (9) next (10) Lk={c∈Ck|c.count≥minsupport}; (11) next (12) resultset=resultset∪Lk 其中, D表示資料庫；minsupport表示給定的最小支持度；resultset表示所有最大項目集。 全國注冊建築師、建造師考試備考資料 歷年真題 考試心得 模擬試題 Sc_candidate函數 該函數的參數為Lk-1,即: 所有最大k-1維項目集,結果返回含有k個項目的侯選項目集Ck。事實上,Ck是k維最大項目集的超集,通過函數count_support計算項目的支持度,然後生成Lk。 該函數是如何完成這些功能的, 詳細說明如下: 首先, 通過對Lk-1自連接操作生成Ck,稱join(連接)步,該步可表述為: insert into Ck select P.item1,P.item2,...,P.itemk-1,Q.itemk-1 from Lk-1P,Lk-1Q where P.item1=Q.item1,...,P.itemk-2=Q.itemk-2,P.itemk-1<Q.itemk-1 若用集合表示:Ck={X∪X'|X,X'∈Lk-1,|X∩X'|=k-2} 然後,是prune(修剪)步,即對任意的c,c∈Ck, 刪除Ck中所有那些(k-1)維子集不在Lk-1 中的項目集,得到侯選項目集Ck。表述為： for all itemset c∈Ck for all (k-1)維子集s of c if(s不屬於Lk-1) then delete c from Ck; 用集合表示:Ck={X∈Ck|X的所有k-1維子集在Lk-1中} 2.Apriori演算法的舉例 示例說明Apriori演算法運作過程，有一資料庫D, 其中有四個事務記錄, 分別表示為 TID Items T1 I1,I3,I4 T2 I2,I3,I5 T3 I1,I2,I3,I5 T4 I2,I5 在Apriori演算法中每一步創建該步的侯選集。統計每個侯選項目集的支持度,並和預定 義的最小支持度比較,來確定該步的最大項目集。 首先統計出一維項目集,即C1.這里預定義最小支持度minsupport=2,侯選項目集中滿足最小支持度要求的項目集組合成最大的1-itemsets。為生成最大的2-itemsets,使用了sc_candidate函數中join步,即：L1joinL1，並通過prune步刪除那些C2的那些子集不在L1中的項目集。生成了侯選項目集C2。搜索D中4個事務,統計C2中每個侯選項目集的支持度。然後和最小支持度比較,生成L2。侯選項目集C3是由L2生成.要求自連接的兩個最大2-itemsets中,第一個項目相同,在L2中滿足該條件的有{I2,I3},{I2,I5}.這兩個集合經過join步後, 產生集合{I2，I3，I5}.在prune步中,測試{I2，I3，I5}的子集{I3，I5},{I2，I3},{I2，I5}是否在L2中,由L2可以知道{I3,I5},{I2,I3},{I2,I5}本身就是最大2-itemsets.即{I2,I3,I5}的子集都是最大項目集.那麼{I2,I3,I5}為侯選3-itemset.然後搜索資料庫中所有事務記錄,生成最大的3-tiemsets L3。此時, 從L3中不能再生成侯選4-itemset 。Apriori演算法結束. 演算法的圖例說明 五、實驗結果 test.txt格式及內容如下： 實驗結果如下： 六、實驗總結 Apriori演算法可以很有效地找出數據集中存在的關聯規則且能找出最大項的關聯規則，但從以上的演算法執行過程可以看到Apriori演算法的缺點: 第一,在每一步產生侯選項目集時循環產生的組合過多，沒有排除不應該參與組合的元素；第二,每次計算項集的支持度時，都對資料庫D中的全部記錄進行了一遍掃描比較，如果是一個大型的資料庫的話，這種掃描比較會大大增加計算機系統的I/O開銷。而這種代價是隨著資料庫的記錄的增加呈現出幾何級數的增加。因此人們開始尋求一種能減少這種系統1/O開銷的更為快捷的演算法。 七、實驗程序 function my_apriori(X,minsup) clc; %%%%主函數，輸入X數據集，判斷產生大於minsup最小支持度的關聯規則 %%%%%%%%%%%%%%%%%%%%%%%%%%打開test.txt文件 file = textread('test.txt','%s','delimiter','\n','whitespace',''); [m,n]=size(file); for i=1:m words=strread(file{i},'%s','delimiter',' '); words=words'; X{i}=words; end %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% minsup=0.3; %預先定義支持度 [m,N]=size(X); %求X的維數 temp=X{1}; %用已暫存變數存儲所有不同項集 for i=2:N temp=union(temp,X{i}); %找出所有不同項（種類） end %%%%%%%%%%%%%%%%%%%%找出k-頻繁項 L=Sc_candidate(temp); %找出2-項候選項集 sum=1; %統計滿足條件的最多項集 while(~isempty(L{1})) %循環終止條件為第k次頻繁項集為空 sum=sum+1; C=count_support(L,X,minsup); %挑選出滿足最小支持度的k-頻繁項 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% sprintf('%s%d%s','滿足要求的',sum,'次頻繁項集依次為') %顯 for i=1:size(C,1) %示 disp(C{i,1}); %部 end %分 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% L=gen_rule(C); %依次產生k-頻繁項(依據apriori演算法規則） End %%%%%%%%%%%%%%%%%%%%%%%%各個子程序如下 function y=cell_union(X,Y) %實現兩cell元組合並功能,由k-1項集增加到k項集函數 [m,n]=size(X); if(~iscellstr(X)) %判斷X是否元組 L{1}=X; L{1,2}=Y; else L=X; L{1,n+1}=Y; end y=L; %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% function y=count_support(L,X,minsup) %找出符合大於支持度sup的候選集,L為候選集，X為總數據集 X=X';%轉置 %%%%%%%%%%%%%%%%%統計頻繁項 [m,n]=size(L); [M,N]=size(X); count=zeros(m,1); for i=1:m for j=1:M if(ismember(L{i},X{j})) count(i)=count(i)+1; end end end %%%%%%%%%%%刪除數據表中不頻繁的項 p=1; C=cell(1); for i=1:m if(count(i)>minsup*M) %小於支持度的項為不頻繁數，將刪除,大於的保留 C{p}=L{i}; p=p+1; end end y=C'; %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% function y=gen_rule(C) %apriori演算法規則判斷是否產生k-候選項集 if(~isempty(C{1})) %判斷C是否為空 [M,N]=size(C); [m,n]=size(C{1}); temp1=C; L=cell(1); for i=1:M temp2{i}=temp1{i}{n}; temp1{i}{n}=[]; end p=1; for i=1:M for j=i+1:M if(isequal(temp1{i},temp1{j})) %判斷前k-1項候選集是否相等 L{p}=cell_union(C{i},temp2{j}); %若相等，則增加至k-項集 p=p+1; end end end y=L'; else y=cell(1);%否則y返回空 end %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% function y=Sc_candidate(C) %產生2-項候選集函數 C=C'; %轉置 [m,n]=size(C); bcount=zeros(m*(m-1)/2,1); L=cell(m*(m-1)/2,1); p=1; for i=1:m-1 %注意 for j=i+1:m L{p}=cell_union(C{i},C{j}); %產生2-項候選集 p=p+1; end end y=L; function y=count_support(L,X,minsup) %找出符合大於支持度sup的候選集,L為候選集，X為總數據集
Ⅳ 關聯規則挖掘演算法的介紹
學號：17020110019 姓名：高少魁
【嵌牛導讀】關聯規則挖掘演算法是數據挖掘中的一種常用演算法，用於發現隱藏在大型數據集中令人感興趣的頻繁出現的模式、關聯和相關性。這里將對該演算法進行簡單的介紹，之後通過Apriori演算法作為實例演示演算法執行結果。
【嵌牛鼻子】數據挖掘 關聯規則挖掘 python
【嵌牛正文】
一、演算法原理
1、基本概念
關聯規則用於發現隱藏在大型數據集中令人感興趣的頻繁出現的模式、關聯和相關性。 而 Apriori演算法則是經典的挖掘頻繁項集的關聯規則演算法，它通過層層迭代來尋找頻繁項集，最後輸出關聯規則：首先掃描數據集，得到 1-頻繁項集，記為 L1，通過合並 L1得到 2-頻繁項集 L2，再通過 L2找到 L3，如此層層迭代，直到找不到頻繁項集為止。
在Apriori演算法中，定義了如下幾個概念：
⚫ 項與項集 ：設 I={i1,i2,…,im}是由 m個不同項構成的集合，其中的每個 ik(k=1,2,…,m)被稱為一個項 (Item)，項的集合 I被稱為項集和，即項集。在實驗中，每一條購物記錄可以被看做 一個項集，用戶購買的某個商品即為一個項。
⚫ 事務與事務集：神乎事務 T是項集 I的一個子集，而事務的全體被稱為事務集。
⚫ 關聯規則：形如 A=>B的表達式，其中， A和 B都屬於項集 I，且 A與 B不相交。
⚫ 支持度：定義如下 support(A=>B) = P(A B)，即 A和 B所含的項在事務集中同時出現的概率。
⚫ 置信度：定義如下 confidence(A⇒B)=support(A⇒B)/support(A)=P(A B)/P(A)=P(B|A)，即如果事務包含 A，則事務中同時出現 B的概率。
⚫ 頻繁項集：如果項集 I的支持度滿足事先定義好的最小支持度閾慧液值（即 I的出現頻度大於相應的最小出現頻度閾值），則 I是頻繁項集。
⚫ 強關聯規則：滿足最小支持度和最小置信度的關聯規則，即待挖掘的關聯規則。
根據以上概念，要實現關聯規則的挖掘，首先要找到所有的頻繁項集，之後找出強關聯規則（即通過多次掃描數據集，找出頻繁集，然後產生關聯規則）。
2、挖掘頻繁項集
在該步驟中有兩個較為重要的部分 ：連接和修剪。連接步驟即使用k-1頻繁項集，通過連接得到 k-候選項集，並且只有相差一個項的項集才能進行連接，如 {A,B}和 {B,C}連接成為 {A,B,C}。修剪步驟基於一個性質：一個 k-項集，如果它的一個 k-1項集（子集）不是頻繁的，那麼它本身也不可能是頻繁的。 因此可以基於這個性質，通過判斷先驗性質來對候選集進行修剪。
3、產生關聯規則
經過連接和修剪之後，即找到了所有的頻繁項集，此時可以在此基礎上產生關聯規則，步驟如下
（1）對於每個頻繁項集 l，產生 l的所有非空子集（這些非空子集一定是頻繁項集）；
（2）對於 l的每一個非空子集 x，計算 confidence(x => (l-x))，如果 confidence(x => (l-x)) confmin，那麼規則 x => (l-x)」成立。
二、演算法設計
1、數據集
通過語句 import xlrd導入相關的庫來進行數據的讀取 。數據內容為十條購物記錄 ，每條購物記錄有若干個商品，表示某個顧客的購買記錄 ，如圖
對於數據載入部分 使用了 xlrd庫中的函數 open_workbook來 打開一個表格文件，使用sheet_by_index函數得到一個工作表， row_values函數即可讀取表格中的內容。由於每個購物記錄的商品數不一定相同，導致讀取的內容含有空格 (』 』)，因此對數據進行刪減以得到緊湊的數據 ，最終讀取數據的結果以列表的游碧悉形式返回。
2、連接
對於連接部分，主要目標是根據已有的k-1頻繁項集生成 k-候選頻繁項集。演算法步驟為：首先將項集中的項按照字典順序排序，之後將 k-1項集中兩個項作比較，如果兩個項集中前 k-2個項是相同的，則可以通過或運算（|）將它們連接起來。
3、修剪
修剪操作主要使用一個判斷函數，通過傳入連接操作後的項集和之前的k-1頻繁項集，對新的項集中的每一個項的補集進行判斷，如果該補集不是 k-1頻繁項集的子集，則證明新的項集不滿足先驗性質，即一個頻繁項集的所有非空子集一定是頻繁的 ，否則就滿足先驗形式。返回布爾類型的參數來供調用它的函數作判斷。
經過連接和修剪步驟之後，項基要成為頻繁項集還必須滿足最小支持度的條件，筆者設計了generateFrequentItems函數來對連接、修剪後產生的 k-候選項集進行判斷，通過遍歷數據集，計算其支持度，滿足最小支持度的項集即是 一個頻繁項集，可將其返回。
以上，經過不斷的遍歷、連接、修剪、刪除，可將得到的所有結果以列表形式返回。筆者還設計了字典類型的變數 support_data，以得到某個頻繁項集及其支持度 。
4、挖掘關聯規則
generateRules函數用來挖掘關聯規則，通過傳入 最小置信度、 頻繁項集及其 支持度來生成規則 。根據定理：對於頻繁項集 l的每一個非空子集 x，計算 confidence(x => (l-x))，如果 confidence(x => (l-x)) confmin，那麼規則 x => (l-x)」成立，因此，該函數重點在掃描頻繁項集，得到每一個子集，並計算置信度，當置信度滿足條件（即大於等於最小置信度）時，生成一條規則。在函數中，使用了元組來表示一條規則，元組中包含 x、 l-x以及其置信度 ，最後返回生成的所有規則的列表。
三、演算法執行結果
設置最大頻繁項集數k為 3，最小支持度為 0.2，最小置信度為 0.8 使用 pycharm運行程序 ，得到以下結果：
由圖中結果可以看出，對於頻繁 1-項集，有五個滿足的項集，頻繁 2-項集有 6個，頻繁 3-項集有 2個，它們都滿足支持度大於或等於最小支持度 0.2。根據頻繁項集，程序得到的關聯規則有三條，即 {麵包 }=>{牛奶 }，，{雞蛋 }=>{牛奶 }，，{麵包，蘋果 }=>{牛奶 其中，這些規則的置信度都是 1.0，滿足大於或等於最小置信度 0.8的條件 。
四、程序源碼
Ⅳ 求MapRece實現Apriori代碼
Apriori，主體分兩步走：
a. 根據 原始數據 得到1 - k項集,再根據support（支持度）得到頻繁1項集，頻繁2項集，頻繁3項集...... 一直到頻繁k項集，這一步是運算量最大的，也是hadoop集群的瓶頸。
b. 根據 置信度 confidence ，得到所有強規則。
因為 b 步驟太簡單，為了省事，我沒寫在演算法里，演算法里只求出了所有頻繁集。而這一步驟也分為兩步：
a. 迭代得到K項集，具體迭代方法就是將上一次迭代的結果k-1項集和1項集進行組合，從而得到K項集。
b. 根據支持度，得到頻繁K項集，不斷迭代a,b步驟，直到K為最大為止。
Ⅵ 鐢∕atlab瀹炵幇apriori綆楁硶鍏寵仈瑙勫垯鐨勬寲鎺樼▼搴忥紝瀹屾暣鏈夎︾粏娉ㄨВ
涓嬮潰榪欐墊槸apriori綆楁硶涓鐢2棰戠箒欏歸泦鎵緆棰戠箒欏歸泦鐨勭▼搴忥紝紼嬪簭涓鏈変袱涓闂棰橈細
1銆佷技涔巜hile寰鐜鐨凨姘歌繙閮芥槸鍥哄畾鐨勶紝涔熷氨鏄閮芥槸棰戠箒2欏歸泦鐨勪釜鏁般傚緱鍒伴戠箒3欏歸泦鍚嶬鐨勪釜鏁頒笉鏄瑕佸彉鍚楋紵濡備綍浣撶幇鍛錛
2銆佺▼搴忎腑鏈変袱涓猣or鐨勫ぇ寰鐜錛屼絾鏄鍙戠幇緇撴灉鏄鍙瑕佹壘鍒頒竴涓棰戠箒3欏歸泦絎浜屼釜for寰鐜灝變細緇撴潫錛屼絾鏄鍏跺疄榪樺簲璇ユ湁鍏跺畠鐨勯戠箒3欏歸泦銆俧or寰鐜涓嶆槸搴旇ユ棤鏉′歡鎵ц屽埌鍙傛暟k緇撴潫鍚楋紵褰撴椂k鍊兼槸15錛屽彲鏄紼嬪簭緇撴潫鐨勬椂鍊檌=2錛宩=3,鐒跺悗j灝變笉鎵ц4浠ュ強涓鐩村埌k鐨勯儴鍒嗕簡銆傛槸浠涔堝師鍥犲憿錛熼夯鐑﹂珮鎵嬫寚鐐逛竴涓嬨傛ュ晩鈥︹
while( k>0)
le=length(candidate{1});
num=2;
nl=0;
for i=1:k-1
for j=i+1:k
x1=candidate{i}; %candidate鍒濆嬪間負棰戠箒2欏歸泦錛岃繖涓琛ㄧず棰戠箒欏歸泦鐨勭琲欏
x2=candidate{j};
c = intersect(x1, x2);
M=0;
r=1;
nn=0;
l1=0;
if (length(c)==le-1) & (sum(c==x1(1:le-1))==le-1)
houxuan=union(x1(1:le),x2(le));
%鏍戝壀鏋,鑻ヤ竴涓鍊欓夐」鐨勬煇涓狵-1欏瑰瓙闆嗕負闈為戠箒錛屽垯鍓鏋濇帀
sub_set=subset(houxuan);
%鐢熸垚璇ュ欓夐」鐨勬墍鏈塊-1欏瑰瓙闆
NN=length(sub_set);
%鍒ゆ柇榪欎簺K-1欏硅嚜宸辨槸鍚﹂兘涓洪戠箒鐨
while(r & M<NN)
M=M+1;
r=in(sub_set{M},candidate);
end
if M==NN
nl=nl+1;
%鍊欓塳欏歸泦
cand{nl}=houxuan;
%璁板綍姣忎釜鍊欓塳欏歸泦鍑虹幇鐨勬℃暟
le=length(cand{1});
for i=1:m
s=cand{nl};
x=X(i,:);
if sum(x(s))==le
nn=nn+1;
end
end
end
end
%浠庡欓夐泦涓鎵鵑戠箒欏歸泦
if nn>=th
ll=ll+1;
candmid{nl}=cand{nl};
pfxj(nl).element=cand{nl};
pfxj(nl).time=nn;
disp('寰楀埌鐨勯戠箒欏歸泦涓:')
result=(candmid{nl});
disp(result);
end
end
end
end
Ⅶ python哪個包實現apriori
要用apriori不需要哪個包，要有一個實現apriori功能的.py文件，將這個文件放置在你要調用的文件相同的地址，然後用fromaprioriimport*來使用。。
apriori.py下載地址：鏈接：https://pan..com/s/1XpKHfUXGDIXj7CcYJL0anA