apriori演算法

1. r apriori演算法結果怎麼看

演算法：Apriori
輸入：D - 事務資料庫；min_sup - 最小支持度計數閾值
輸出：L - D中的頻繁項集
方法：
L1=find_frequent_1-itemsets(D); // 找出所有頻繁1項集
For(k=2;Lk-1!=null;k++){
Ck=apriori_gen(Lk-1); // 產生候選，並剪枝
For each 事務t in D{ // 掃描D進行候選計數
Ct =subset(Ck,t); // 得到t的子集
For each 候選c 屬於 Ct
c.count++;
}
Lk={c屬於Ck | c.count>=min_sup}
}
Return L=所有的頻繁集；

Procere apriori_gen(Lk-1:frequent(k-1)-itemsets)
For each項集l1屬於Lk-1
For each項集 l2屬於Lk-1
If((l1[1]=l2[1])( l1[2]=l2[2])……..
(l1[k-2]=l2[k-2])(l1[k-1]<l2[k-1])) then{
c=l1連接l2 //連接步：產生候選
if has_infrequent_subset(c,Lk-1) then
delete c; //剪枝步：刪除非頻繁候選
else add c to Ck;
}
Return Ck;

Procere has_infrequent_sub(c:candidate k-itemset; Lk-1:frequent(k-1)-itemsets)
For each(k-1)-subset s of c
If s不屬於Lk-1 then
Return true;
Return false;

2. apriori演算法使用了什麼性質

Apriori性質：一個頻繁項集的任一子集也應該是頻繁項集。證明根據定義，若一個項集I不滿足最小支持度閾值min_sup，則I不是頻繁的，即P（I）<min_sup。若增加一個項A到項集I中，則結果新項集（I∪A）也不是頻繁的，在整個事務資料庫中所出現的次數也不可能多於原項集I出現的次數，因此P（I∪A）<min_sup，即（I∪A）也不是頻繁的。這樣就可以根據逆反公理很容易地確定Apriori性質成立。
http://ke..com/link?url=8F29ZS1ufQ4gtAsaXsyZr__Eut632ia

3. 數據挖掘中的apriori演算法的具體步驟是什麼

演算法：Apriori
輸入：D - 事務資料庫；min_sup - 最小支持度計數閾值
輸出：L - D中的頻繁項集
方法：
L1=find_frequent_1-itemsets(D); // 找出所有頻繁1項集
For(k=2;Lk-1!=null;k++){
Ck=apriori_gen(Lk-1); // 產生候選，並剪枝
For each 事務t in D{ // 掃描D進行候選計數
Ct =subset(Ck,t); // 得到t的子集
For each 候選c 屬於 Ct
c.count++;
}
Lk={c屬於Ck | c.count>=min_sup}
}
Return L=所有的頻繁集；

Procere apriori_gen(Lk-1:frequent(k-1)-itemsets)
For each項集l1屬於Lk-1
For each項集 l2屬於Lk-1
If((l1[1]=l2[1])&&( l1[2]=l2[2])&&……..
&& (l1[k-2]=l2[k-2])&&(l1[k-1]<l2[k-1])) then{
c=l1連接l2 //連接步：產生候選
if has_infrequent_subset(c,Lk-1) then
delete c; //剪枝步：刪除非頻繁候選
else add c to Ck;
}
Return Ck;

Procere has_infrequent_sub(c:candidate k-itemset; Lk-1:frequent(k-1)-itemsets)
For each(k-1)-subset s of c
If s不屬於Lk-1 then
Return true;
Return false;

4. 用Matlab實現apriori演算法關聯規則的挖掘程序，完整有詳細註解

下面這段是apriori演算法中由2頻繁項集找k頻繁項集的程序，程序中有兩個問題：
1、似乎while循環的K永遠都是固定的，也就是都是頻繁2項集的個數。得到頻繁3項集後K的個數不是要變嗎？如何體現呢？
2、程序中有兩個for的大循環，但是發現結果是只要找到一個頻繁3項集第二個for循環就會結束，但是其實還應該有其它的頻繁3項集。for循環不是應該無條件執行到參數k結束嗎？當時k值是15，可是程序結束的時候i=2，j=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項集，這個表示頻繁項集的第i項
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));
%樹剪枝,若一個候選項的某個K-1項子集為非頻繁，則剪枝掉
sub_set=subset(houxuan);
%生成該候選項的所有K-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;
%候選k項集
cand{nl}=houxuan;
%記錄每個候選k項集出現的次數
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

5. 如何實現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);
	}
	}
	}
	}
	

6. Apriori演算法是什麼適用於什麼情境

經典的關聯規則挖掘演算法包括Apriori演算法和FP-growth演算法。apriori演算法多次掃描交易資料庫，每次利用候選頻繁集產生頻繁集；而FP-growth則利用樹形結構，無需產生候選頻繁集而是直接得到頻繁集，大大減少掃描交易資料庫的次數，從而提高了演算法的效率。但是apriori的演算法擴展性較好，可以用於並行計算等領域。

Apriori algorithm是關聯規則里一項基本演算法。是由Rakesh Agrawal和Ramakrishnan Srikant兩位博士在1994年提出的關聯規則挖掘演算法。關聯規則的目的就是在一個數據集中找出項與項之間的關系，也被稱為購物藍分析 (Market Basket analysis)，因為「購物藍分析」很貼切的表達了適用該演算法情景中的一個子集。

7. 請問以下題目用apriori演算法怎麼做

這個題跟allelectronics數據集是一樣的
你網路一下apriori allelectronics
或者找找《數據挖掘概念與技術》就會了
只能講到這了

8. apriori演算法的計算復雜度受什麼影響

一個演算法的時間復雜度和其空間復雜度的關系可這樣理解
一個演算法要做高效率低存儲是很困難的，也就是說，演算法的時間復雜度小，可能需要較大的空間復雜度。反之亦然。也可以說，通過空間換得時間
希望我的回答可以幫到您哦

9. Apriori演算法的核心是

• 連接和剪枝。

• 簡言之就是對一個已知的交易資料庫D，有一個最小支持閾值min_support，即為該演算法的輸入；演算法的輸出為滿足最小支持閾值的頻繁項集L。

• 具體為：掃描D，對每個交易商品（T1，...，Tk---1項候選項集）計數，找出滿足計數大於min_support的項集，即為1項頻繁集L1；

• 關鍵的來了：如何由1項頻繁集L1產生2項候選項集C2，此步稱為連接。

• 如何由C2得到L2，此步即為剪枝。從C2中找出計數大於min_support的項集，即為L2。

• 重復以上過程，增大頻繁項集的長度，直至沒有更長的頻繁項集。
  

10. 如何提高apriori演算法的效率

Apriori演算法是關聯規則挖掘中的經典演算法。在Apriori演算法中,使用頻繁項集的先驗知識,逐層搜索的迭代方法,通過掃描資料庫,累積每個項的計數,並收集滿足最小支持度的項,找每個Lk都需要掃描一次資料庫。演算法的效率隨著數據量的增大,頻繁項集的增多,演算法的效率就非常的低,本文通過對Apriori演算法分析,應用散列、事務壓縮、劃分、抽樣等方法,最大可能的減少資料庫掃描的次數,快速發現頻繁項集,提高Apriori演算法的效率。