apriori _生活經驗

apriori算法有哪些優點?Apriori算法使用Apriori性質來生產候選項集的方法，大大壓縮了頻繁集的大小，取得了很好的性能。

Apriori算法的問題【apriori】不知道你知不知道什么叫泛型，你可以寫成List ，然后在while中給transact賦值，比如說transact.setContener(contener)然后，把你需要的字段全部set進去，然后在transList.add(transact) 。ok問題解決。
如果你這都看不懂的話，建議去看看書

數據挖掘中的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=所有的頻繁集；

Procedure 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;

Procedure 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;

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

apriori算法的偽代碼是什么意思？偽代碼要出現在程序里面嗎？偽代碼是一種介于編程語言和自然語言的東東，用于描述算法，目的是既便于閱讀，稍加改變后就可直接形成程序代碼。看來你初涉數據挖掘但沒有計算機基礎，偽代碼屬于基本概念。

什么是數據庫?

文章插圖

數據庫就是儲存數據的地方。在電腦中，在內存中，在硬盤中的東西都是存儲在數據庫中的數據。而這些數據所待的地方就叫做數據庫。也可以稱為電子化的“文件柜” 。在計算機科學與應用中的數據庫意味著今后數據會越來越龐大，也意味著數據在以后的發展中在重多的科學還有應用中要運用到更多的數據。擴展資料：數據庫管理系統可以依據它所支持的數據庫模型來作分類，例如關系式、XML；或依據所支持的計算機類型來作分類，例如服務器群集、或依據所用查詢語言來作分類，例如SQL、XQuery；或依據性能沖量重點來作分類，例如最大規模、最高運行速度的分類方式。不論使用哪種分類方式，一些DBMS能夠跨類別，同時支持多種查詢語言。早期比較流行的數據庫模型有三種，而在當今的互聯網中最常見的就是關系型數據庫和非關系型數據庫。參考資料：百度百科-數據庫
數據庫是什么意思？

文章插圖

數據庫，簡而言之可視為電子化的文件柜——存儲電子文件的處所，用戶可以對文件中的數據進行新增、截取、更新、刪除等操作。由于資料集中管理，電腦的資源便可由使用者共享，而且資料的保密及處理的一致性更容易達成。數據庫將相關數據的集合存儲在一起的，這些數據是結構化的，無有害的或不必要的冗余，并為多種應用服務；數據的存儲獨立于使用它的程序；對數據庫插入新數據，修改和檢索原有數據均能按一種公用的和可控制的方式進行。擴展資料：數據庫一般具備具有存儲、截取、安全保障、備份等基礎功能的數據庫管理系統。數據庫管理系統可以依據它所支持的數據庫模型來作分類，或依據所支持的計算機類型來作分類，或依據所用查詢語言來作分類，或依據性能沖量重點來作分類。而且擁有有數據索引的功能。像是一本書前面幾頁都有目錄，目錄也算是索引的一種，只是它的分類較廣，例如車牌、身份證字號、條碼等，都是一個索引的號碼，可以從號碼中看出其中的端倪，若是要找的人、車或物品，也只要提供相關的號碼，即可迅速查到正確的人事物。參考資料來源：百度百科——數據庫
數據庫中@代表什么意思

文章插圖

數據庫中＠代表是局部變量聲明。用于存儲過程中。格式是＠參數名數據類型［VARYING］［＝內定值］［OUTPUT］。每個參數名前要有一個“＠”符號，每一個存儲過程的參數僅為該程序內部使用，參數的類型除了IMAGE外，其他SQL Server所支持的數據類型都可使用。擴展資料：在建立數據庫時通過＠設定一個字段參數的默認值。如果＠的字段參數是既有輸入又有輸出值的，也就是在調用了這個存儲過程時，如果所指定的參數值是需要輸入的參數，同時也需要在結果中輸出的，則該項必須為OUTPUT 。而如果＠的字段參數只是做輸出參數用，則可以用CURSOR，同時在使用該參數時，必須指定VARYING和OUTPUT這兩個語句。
數據庫是干什么用的呢

文章插圖

數據庫是以一定方式儲存在一起、能與多個用戶共享、具有盡可能小的冗余度、與應用程序彼此獨立的數據集合，可視為電子化的文件柜——存儲電子文件的處所，用戶可以對文件中的數據進行新增、查詢、更新、刪除等操作。數據庫是存放數據的倉庫。它的存儲空間很大，可以存放百萬條、千萬條、上億條數據。但是數據庫并不是隨意地將數據進行存放，是有一定的規則的，否則查詢的效率會很低。當今世界是一個充滿著數據的互聯網世界，充斥著大量的數據。即這個互聯網世界就是數據世界。數據的來源有很多，比如出行記錄、消費記錄、瀏覽的網頁、發送的消息等等。除了文本類型的數據，圖像、音樂、聲音都是數據。擴展資料：數據庫發展現狀在數據庫的發展歷史上，數據庫先后經歷了層次數據庫、網狀數據庫和關系數據庫等各個階段的發展，數據庫技術在各個方面的快速的發展。特別是關系型數據庫已經成為目前數據庫產品中最重要的一員，80年代以來，幾乎所有的數據庫廠商新出的數據庫產品都支持關系型數據庫，即使一些非關系數據庫產品也幾乎都有支持關系數據庫的接口。參考資料來源：百度百科-數據參考資料來源：百度百科-數據庫
利用Apriori算法產生頻繁項集，（min sup=0.6），給出具體計算過程？Apriori算法是一種發現頻繁項集的基本算法。算法使用頻繁項集性質的先驗知識。Apriori算法使用一種稱為逐層搜索的迭代方法，其中K項集用于探索(k+1)項集。首先，通過掃描數據庫，累計每個項的計數，并收集滿足最小支持度的項，找出頻繁1項集的集合。該集合記為L1.然后，使用L1找出頻繁2項集的集合L2，使用L2找到L3，如此下去，直到不能再找到頻繁k項集。Apriori算法的主要步驟如下：(1)掃描事務數據庫中的每個事務，產生候選1．項集的集合Cl；(2)根據最小支持度min_sup，由候選l-項集的集合Cl產生頻繁1一項集的集合Ll；(3)對k=l；(4)由Lk執行連接和剪枝操作，產生候選(k+1)．項集的集合Ck+l-(5)根據最小支持度min_sup，由候選(k+1)一項集的集合Ck+l產生頻繁(k+1)-項集的集合Lk+1．(6)若L?≠①，則k．k+1，跳往步驟(4)；否則，跳往步驟(7)；(7)根據最小置信度min_conf,由頻繁項集產生強關聯規則，結束。

apriori算法找頻繁項集這是我的解題過程，希望你能看明白，或者你已經有正確答案了，也希望能共享一下！謝謝
如何實現apriori算法import java.util.HashMap;import java.util.HashSet;import java.util.Iterator;import java.util.Map;import java.util.Set;import java.util.TreeMap;/*** 關聯規則挖掘：Apriori算法* * 按照Apriori算法的基本思想來實現* * @author king* @since 2013/06/27* */public class Apriori { private Map> txDatabase; // 事務數據庫 private Float minSup; // 最小支持度 private Float minConf; // 最小置信度 private Integer txDatabaseCount; // 事務數據庫中的事務數private Map>> freqItemSet; // 頻繁項集集合 private Map, Set>> assiciationRules; // 頻繁關聯規則集合public Apriori(Map> txDatabase,Float minSup,Float minConf) {this.txDatabase = txDatabase;this.minSup = minSup;this.minConf = minConf;this.txDatabaseCount = this.txDatabase.size();freqItemSet = new TreeMap>>();assiciationRules = new HashMap, Set>>(); }/** * 掃描事務數據庫，計算頻繁1-項集 * @return */ public Map, Float> getFreq1ItemSet() {Map, Float> freq1ItemSetMap = new HashMap, Float>();Map, Integer> candFreq1ItemSet = this.getCandFreq1ItemSet();Iterator, Integer>> it = candFreq1ItemSet.entrySet().iterator();while(it.hasNext()) {Map.Entry, Integer> entry = it.next();// 計算支持度Float supported = new Float(entry.getValue().toString())/new Float(txDatabaseCount);if(supported>=minSup) {freq1ItemSetMap.put(entry.getKey(), supported);}}return freq1ItemSetMap; }/** * 計算候選頻繁1-項集 * @return */ public Map, Integer> getCandFreq1ItemSet() {Map, Integer> candFreq1ItemSetMap = new HashMap, Integer>();Iterator>> it = txDatabase.entrySet().iterator();// 統計支持數，生成候選頻繁1-項集while(it.hasNext()) {Map.Entry> entry = it.next();Set itemSet = entry.getValue();for(String item : itemSet) {Set key = new HashSet();key.add(item.trim());if(!candFreq1ItemSetMap.containsKey(key)) {Integer value = https://www.zaoxu.com/jjsh/bkdq/1;candFreq1ItemSetMap.put(key, value);}else {Integer value = 1+candFreq1ItemSetMap.get(key);candFreq1ItemSetMap.put(key, value);}}}return candFreq1ItemSetMap; }/** * 根據頻繁(k-1)-項集計算候選頻繁k-項集 ** @param m 其中m=k-1 * @param freqMItemSet 頻繁(k-1)-項集 * @return */ public Set> aprioriGen(int m, Set> freqMItemSet) {Set> candFreqKItemSet = new HashSet>();Iterator> it = freqMItemSet.iterator();Set originalItemSet = null;while(it.hasNext()) {originalItemSet = it.next();Iterator> itr = this.getIterator(originalItemSet, freqMItemSet);while(itr.hasNext()) {Set identicalSet = new HashSet(); // 兩個項集相同元素的集合(集合的交運算)identicalSet.addAll(originalItemSet);Set set = itr.next();identicalSet.retainAll(set); // identicalSet中剩下的元素是identicalSet與set集合中公有的元素if(identicalSet.size() == m-1) { // (k-1)-項集中k-2個相同Set differentSet = new HashSet(); // 兩個項集不同元素的集合(集合的差運算)differentSet.addAll(originalItemSet);differentSet.removeAll(set); // 因為有k-2個相同，則differentSet中一定剩下一個元素，即differentSet大小為1differentSet.addAll(set); // 構造候選k-項集的一個元素(set大小為k-1,differentSet大小為k)if(!this.has_infrequent_subset(differentSet, freqMItemSet))candFreqKItemSet.add(differentSet); // 加入候選k-項集集合}}}return candFreqKItemSet; }/*** 使用先驗知識，剪枝。若候選k項集中存在k-1項子集不是頻繁k-1項集，則刪除該候選k項集* @param candKItemSet* @param freqMItemSet* @return*/ private boolean has_infrequent_subset(Set candKItemSet, Set> freqMItemSet) {Set tempSet = new HashSet();tempSet.addAll(candKItemSet);Iterator itItem = candKItemSet.iterator();while(itItem.hasNext()) {String item = itItem.next();tempSet.remove(item);// 該候選去掉一項后變為k-1項集if(!freqMItemSet.contains(tempSet))// 判斷k-1項集是否是頻繁項集return true;tempSet.add(item);// 恢復}return false; }/** * 根據一個頻繁k-項集的元素(集合) ，獲取到頻繁k-項集的從該元素開始的迭代器實例 * @param itemSet * @param freqKItemSet 頻繁k-項集 * @return */ private Iterator> getIterator(Set itemSet, Set> freqKItemSet) {Iterator> it = freqKItemSet.iterator();while(it.hasNext()) {if(itemSet.equals(it.next())) {break;}}return it; }/** * 根據頻繁(k-1)-項集，調用aprioriGen方法，計算頻繁k-項集 ** @param k* @param freqMItemSet 頻繁(k-1)-項集 * @return */ public Map, Float> getFreqKItemSet(int k, Set> freqMItemSet) {Map, Integer> candFreqKItemSetMap = new HashMap, Integer>();// 調用aprioriGen方法，得到候選頻繁k-項集Set> candFreqKItemSet = this.aprioriGen(k-1, freqMItemSet);// 掃描事務數據庫Iterator>> it = txDatabase.entrySet().iterator();// 統計支持數while(it.hasNext()) {Map.Entry> entry = it.next();Iterator> kit = candFreqKItemSet.iterator();while(kit.hasNext()) {Set kSet = kit.next();Set set = new HashSet();set.addAll(kSet);set.removeAll(entry.getValue()); // 候選頻繁k-項集與事務數據庫中元素做差運算if(set.isEmpty()) { // 如果拷貝set為空，支持數加1if(candFreqKItemSetMap.get(kSet) == null) {Integer value = 1;candFreqKItemSetMap.put(kSet, value);}else {Integer value = 1+candFreqKItemSetMap.get(kSet);candFreqKItemSetMap.put(kSet, value);}}}}

我用spss clementine中的 Apriori做數據挖掘,怎么得到的支持度和置信度值不對呢spss clementine
的定義有問題，他的支持度其實是前向的出現概率
和統計定義不同，你選擇條件支持度
統計研究生專業數據分析

數據挖掘關聯規則中的“支持度”和“置信度”一般設為多少？《數據挖掘：概念與技術》上面寫到：
“關聯規則被認為是有趣的，如果它滿足最小支持度閾值和最小置信度閾值。這些閾值可以由用戶或領域專家設定。”

我認為可以根據你現有的數據集，做實驗，通過實驗結果來確定那個閾值比較合理。因為閾值與數據集是有很大關系的。

關聯規則apriori算法用什么軟件做1.1什么是關聯規則
一言蔽之，關聯規則是形如X→Y的蘊涵式，表示通過X可以推導“得到”Y，其中X和Y分別稱為關聯規則的先導(antecedent或left-hand-side, LHS)和后繼(consequent或right-hand-side, RHS)
1.2如何量化關聯規則
關聯規則挖掘的一個典型例子便是購物車分析。通過關聯規則挖掘能夠發現顧客放入購物車中的不同商品之間的關聯，分析顧客的消費習慣。這種關聯規則的方向能夠幫助賣家了解哪些商品被顧客頻繁購買，從而幫助他們開發更好的營銷策略。比如：將經常同時購買的商品擺近一些，以便進一步刺激這些商品一起銷售；或者，將兩件經常同時購買的商品擺遠一點，這樣可能誘發買這兩件商品的用戶一路挑選其他商品。
在數據挖掘當中，通常用“支持度”（support）和“置性度”（confidence）兩個概念來量化事物之間的關聯規則。它們分別反映所發現規則的有用性和確定性。比如：
Computer => antivirus_software , 其中 support=2%, confidence=60%
表示的意思是所有的商品交易中有2%的顧客同時買了電腦和殺毒軟件，并且購買電腦的顧客中有60%也購買了殺毒軟件。在關聯規則的挖掘過程中，通常會設定最小支持度閾值和最小置性度閾值，如果某條關聯規則滿足最小支持度閾值和最小置性度閾值，則認為該規則可以給用戶帶來感興趣的信息。
1.3關聯規則挖掘過程
1）幾個基本概念：
關聯規則A->B的支持度support=P(AB)，指的是事件A和事件B同時發生的概率。
置信度confidence=P(B|A)=P(AB)/P(A),指的是發生事件A的基礎上發生事件B的概率。
同時滿足最小支持度閾值和最小置信度閾值的規則稱為強規則。
如果事件A中包含k個元素，那么稱這個事件A為k項集，并且事件A滿足最小支持度閾值的事件稱為頻繁k項集。
2）挖掘過程：
第一，找出所有的頻繁項集；
第二，由頻繁項集產生強規則。
2．什么是Apriori
2.1Apriori介紹
Apriori算法使用頻繁項集的先驗知識，使用一種稱作逐層搜索的迭代方法，k項集用于探索(k+1)項集。首先，通過掃描事務（交易）記錄，找出所有的頻繁1項集，該集合記做L1，然后利用L1找頻繁2項集的集合L2，L2找L3，如此下去，直到不能再找到任何頻繁k項集。最后再在所有的頻繁集中找出強規則，即產生用戶感興趣的關聯規則。
其中，Apriori算法具有這樣一條性質：任一頻繁項集的所有非空子集也必須是頻繁的。因為假如P(I)< 最小支持度閾值，當有元素A添加到I中時，結果項集（A∩I）不可能比I出現次數更多。因此A∩I也不是頻繁的。
2.2連接步和剪枝步
在上述的關聯規則挖掘過程的兩個步驟中，第一步往往是總體性能的瓶頸。Apriori算法采用連接步和剪枝步兩種方式來找出所有的頻繁項集。
1）連接步
為找出Lk（所有的頻繁k項集的集合），通過將Lk-1（所有的頻繁k-1項集的集合）與自身連接產生候選k項集的集合。候選集合記作Ck 。設l1和l2是Lk-1中的成員。記li[j]表示li中的第j項。假設Apriori算法對事務或項集中的項按字典次序排序，即對于（k-1）項集li，li[1]<li[2]<……….<li[k-1] 。將Lk-1與自身連接，如果(l1[1]=l2[1])&&( l1[2]=l2[2])&&……..&& (l1[k-2]=l2[k-2])&&(l1[k-1]<l2[k-1]) ，那認為l1和l2是可連接。連接l1和l2 產生的結果是{l1[1],l1[2],……,l1[k-1],l2[k-1]} 。
2）剪枝步
CK是LK的超集，也就是說， CK的成員可能是也可能不是頻繁的。通過掃描所有的事務（交易），確定CK中每個候選的計數，判斷是否小于最小支持度計數，如果不是，則認為該候選是頻繁的。為了壓縮Ck,可以利用Apriori性質：任一頻繁項集的所有非空子集也必須是頻繁的，反之，如果某個候選的非空子集不是頻繁的，那么該候選肯定不是頻繁的，從而可以將其從CK中刪除。
（Tip：為什么要壓縮CK呢？因為實際情況下事務記錄往往是保存在外存儲上，比如數據庫或者其他格式的文件上，在每次計算候選計數時都需要將候選與所有事務進行比對，眾所周知，訪問外存的效率往往都比較低，因此Apriori加入了所謂的剪枝步，事先對候選集進行過濾，以減少訪問外存的次數。）

關于數據挖掘中的apriori算法，幫忙推出關聯規則事務數為 5 支持度為0.6，置信度為0.6abc的支持數P1=3，acd的支持數P2=3，bcd的支持數P3=3，關聯規則的輸出就是在由頻繁項集的項組成的關聯規則中，找出置信度大于等于最小置信度閾值的關聯規則。因為由頻繁項集的項組成的關聯規則的支持度大于等于最小支持閾值，所以規則產生過程就是在由頻繁項集的項組成的關聯規則中，找出置信度大于等于最小置信度閾值的強關聯規則，基本步驟如下：
1）對于每個頻繁項集L，產生L的所有非空真子集。
2）對于L的每個非空真子集，如果L的支持計數除以的支持計數大于等于最小置信度閾值min_conf，則輸出強關聯規則 =>（L- ）。
例如：abc的非空真子集有a，b ， c ， ab，ac，bc 。分別算出他們的支持數，再除以abc的支持數，若結果大于0.6則可輸出強關聯規則。Pa/P1=4/3>0.6,則可以輸出關聯規則：a=>bc；同理可輸出強關聯規則：b=>ac，c=>ab；
同理，對于acd，bcd采用同樣地方法。

請教推薦算法中關聯規則的最小支持度和最小置信度如何確認apriori算法有支持度和置信度兩個概念，都是在執行算法之前自己設定的，在每一次迭代過程后，大于支持度的項集被保留為頻繁項集，最后生成的規則由最終的頻繁項集組成，簡單說也就是支持度越小，頻繁項集越多，置信度越小

python哪個包實現apriori如連接中的例子，雖然新的{I1, I2, I3, I4}項集滿足子集{I1, I2, I3}; {I1, I2, I4} 都是頻繁項集，但其他子集也得滿足，這里特指剩下兩個{I1, I3, I4},{I2, I3, I4} 。所以驗證一下他們，如果他們不滿足，可根據定理1 ，新的項集也肯定不頻繁。

所以剪枝的過程就是驗證Ck中所有項集的所有k-1子集是否都頻繁（只要看看他們是不是在Lk-1集合中即可），這樣雖然要檢查很多遍，但不需要對整個數據庫進行遍歷就能篩去許多不滿足的情況。

上述方法是經典的Apriori算法，這兩個步驟在k較高（3或以上）時效果非常好，因為商品同時存在的可能性會隨k增大顯著減小。

但是在k=2的時候（k=1用不到Apriori算法，必須遍歷一遍數據庫，相當于“鏈引發”），因為1項集一般都是頻繁的，所以上述兩個步驟基本上相當于沒有用，還得遍歷C(n,2)次數據庫， n為頻繁1項集的數量。

有大神會用Python做關聯規則apriori算法嗎#include #include using namespace std; class Vector { private: int size, length; int * data; public: Vector(int input_size) { size = input_size; length = 0; data = https://www.zaoxu.com/jjsh/bkdq/new int[size]; } }; int main() { int n; cin >> n; Vector arr(n)...

python apriori算法代碼怎么實現class Apriori(object):def __init__(self, filename, min_support, item_start, item_end):self.filename = filenameself.min_support = min_support # 最小支持度self.min_confidence = 50self.line_num = 0 # item的行數self.item_start = item_start #取哪行的itemself.item_end = item_endself.location = [[i] for i in range(self.item_end - self.item_start + 1)]self.support = self.sut(self.location)self.num = list(sorted(set([j for i in self.location for j in i])))# 記錄itemself.pre_support = [] # 保存前一個support,location,numself.pre_location = []self.pre_num = []self.item_name = [] # 項目名self.find_item_name()self.loop()self.confidence_sup()def deal_line(self, line):"提取出需要的項"return [i.strip() for i in line.split(' ') if i][self.item_start - 1:self.item_end]def find_item_name(self):"根據第一行抽取item_name"with open(self.filename, 'r') as F:for index,line in enumerate(F.readlines()):if index == 0:self.item_name = self.deal_line(line)breakdef sut(self, location):"""輸入[[1,2,3],[2,3,4],[1,3,5]...]輸出每個位置集的support [123,435,234...]"""with open(self.filename, 'r') as F:support = [0] * len(location)for index,line in enumerate(F.readlines()):if index == 0: continue# 提取每信息item_line = self.deal_line(line)for index_num,i in enumerate(location):flag = 0for j in i:if item_line[j] != 'T':flag = 1breakif not flag:support[index_num] += 1self.line_num = index # 一共多少行,出去第一行的item_namereturn supportdef select(self, c):"返回位置"stack = []for i in self.location:for j in self.num:if j in i:if len(i) == c:stack.append(i)else:stack.append([j] + i)# 多重列表去重import itertoolss = sorted([sorted(i) for i in stack])location = list(s for s,_ in itertools.groupby(s))return locationdef del_location(self, support, location):"清除不滿足條件的候選集"# 小于最小支持度的剔除for index,i in enumerate(support):if iself.min_confidence:print ','.join(s) , '->>' , self.item_name[each_location[index]] , ' min_support: ' , str(support) + '%' , ' min_confidence:' , str(confidence) + '%'def main():c = Apriori('basket.txt', 14, 3, 13)d = Apriori('simple.txt', 50, 2, 6)if __name__ == '__main__':main()Apriori(filename, min_support, item_start, item_end)參數說明filename:(路徑)文件名min_support:最小支持度item_start:item起始位置item_end:item結束位置import aprioric = apriori.Apriori('basket.txt', 11, 3, 13)輸出：
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算法使用了什么性質Apriori性質：一個頻繁項集的任一子集也應該是頻繁項集。證明根據定義，若一個項集I不滿足最小支持度閾值min_sup，則I不是頻繁的，即P（I）<min_sup 。若增加一個項A到項集I中，則結果新項集（I∪A）也不是頻繁的，在整個事務數據庫中所出現的次數也不可能多于原項集I出現的次數，因此P（I∪A）<min_sup，即（I∪A）也不是頻繁的。這樣就可以根據逆反公理很容易地確定Apriori性質成立。
http://baike.baidu.com/link?url=8F29ZS1ufQ4gtAsaXsyZr_lOEn0I6VOGVoeszB7nCesMkZxU4vWNKnHeDyKWvXjSjTYiRtLoLs1OJ_Eut632ia

python apriori包怎么使用classApriori(object):def__init__(self,filename,min_support,item_start,item_end):self.filename=filenameself.min_support=min_support#最小支持度self.min_confidence=50self.line_num=0#item的行數self.item_start=item_start#取哪行的itemself.item_end=item_endself.location=[[i]foriinrange(self.item_end-self.item_start+1)]self.support=self.sut(self.location)self.num=list(sorted(set([jforiinself.locationforjini])))#記錄itemself.pre_support=[]#保存前一個support,location,numself.pre_location=[]self.pre_num=[]self.item_name=[]#項目名self.find_item_name()self.loop()self.confidence_sup()defdeal_line(self,line):"提取出需要的項"return[i.strip()foriinline.split('')ifi][self.item_start-1:self.item_end]deffind_item_name(self):"根據第一行抽取item_name"withopen(self.filename,'r')asF:forindex,lineinenumerate(F.readlines()):ifindex==0:self.item_name=self.deal_line(line)breakdefsut(self,location):"""輸入[[1,2,3],[2,3,4],[1,3,5]]輸出每個位置集的support[123,435,234]"""withopen(self.filename,'r')asF:support=[0]*len(location)forindex,lineinenumerate(F.readlines()):ifindex==0:continue#提取每信息item_line=self.deal_line(line)forindex_num,iinenumerate(location):flag=0forjini:ifitem_line[j]!='T':flag=1breakifnotflag:support[index_num]+=1self.line_num=index#一共多少行,出去第一行的item_namereturnsupportdefselect(self,c):"返回位置"stack=[]foriinself.location:forjinself.num:ifjini:iflen(i)==c:stack.append(i)else:stack.append([j]+i)#多重列表去重importitertoolss=sorted([sorted(i)foriinstack])location=list(sfors,_initertools.groupby(s))returnlocationdefdel_location(self,support,location):"清除不滿足條件的候選集"#小于最小支持度的剔除forindex,iinenumerate(support):ifiself.min_confidence:print','.join(s),'->>',self.item_name[each_location[index]],'min_support:',str(support)+'%','min_confidence:',str(confidence)+'%'defmain():c=Apriori('basket.txt',14,3,13)d=Apriori('simple.txt',50,2,6)if__name__=='__main__':main()Apriori(filename,min_support,item_start,item_end)參數說明filename:(路徑)文件名min_support:最小支持度item_start:item起始位置item_end:item結束位置importaprioric=apriori.Apriori('basket.txt',11,3,13)輸出：

python 有apriori算法的模塊嗎Apriori算法是數據挖掘中頻發模式挖掘的鼻祖，從60年代就開始流行，其算法思想也十分簡單樸素，首先挖掘出長度為1的頻繁模式，然后k=2
將這些頻繁模式合并組成長度為k的頻繁模式，算出它們的頻繁次數，而且要保證其所有k-1長度的子集也是頻繁的，值得注意的是，為了避免重復，合并的時候，只合并那些前k-2個字符都相同，而k-1的字符一邊是少于另一邊的。
以下是算法的Python實現：

[python] view plain copy print?
__author__ = 'linfuyuan'
min_frequency = int(raw_input('please input min_frequency:'))
file_name = raw_input('please input the transaction file:')
transactions = []

def has_infrequent_subset(candidate, Lk):
for i in range(len(candidate)):
subset = candidate[:-1]
subset.sort()
if not ''.join(subset) in Lk:
return False
lastitem = candidate.pop()
candidate.insert(0, lastitem)
return True

def countFrequency(candidate, transactions):
count = 0
for transaction in transactions:
if transaction.issuperset(candidate):
count += 1
return count

with open(file_name) as f:
for line in f.readlines():
line = line.strip()
tokens = line.split(',')
if len(tokens) > 0:
transaction = set(tokens)
transactions.append(transaction)
currentFrequencySet = {}
for transaction in transactions:
for item in transaction:
time = currentFrequencySet.get(item, 0)
currentFrequencySet[item] = time + 1
Lk = set()
for (itemset, count) in currentFrequencySet.items():
if count >= min_frequency:
Lk.add(itemset)
print ', '.join(Lk)

while len(Lk) > 0:
newLk = set()
for itemset1 in Lk:
for itemset2 in Lk:
cancombine = True
for i in range(len(itemset1)):
if i < len(itemset1) - 1:
cancombine = itemset1[i] == itemset2[i]
if not cancombine:
break
else:
cancombine = itemset1[i] < itemset2[i]
if not cancombine:
break
if cancombine:
newitemset = []
for char in itemset1:
newitemset.append(char)
newitemset.append(itemset2[-1])
if has_infrequent_subset(newitemset, Lk) and countFrequency(newitemset, transactions) >= min_frequency:
newLk.add(''.join(newitemset))
print ', '.join(newLk)
Lk = newLk

scikit-learn 是不是沒有 Apriori，FP-Growth 的 APIscikit-learn 是不是沒有 Apriori，FP-Growth 的 API
Python開源工具包：scikit-learn 是關于機器學習的開發包，主頁：http://scikit-learn.org/stable/index.html
這個包把經典的機器學習算法都利用python進行了實現，是學習機器學習很好理論與實踐結合材料，但是在安裝scikit-learn 出現各種奇怪問題，這里做一個總結。
為了方便以后python各類工具包安裝，可以先安裝python easy_install

在weka中apriori算法無法使用?。ㄎ業氖菔譴觘xcel格式轉換成csv格式導入weka中）numeric就不是離散的，需要做預處理。
用NumericalToNominal過濾器離散化

sklearn 為什么沒有apriori算法本劇已經確定被刪的劇目有：

問讀音：null，Apriori，FP-Growth的讀法漢語標出可真不準確，不方便啊
servlet /sə:vlit/--/se wu li te/
HTML 就是一個一個字母的讀，它是hyper text markup language簡寫
null /nʌl/--/na ou/

apriori 英文發音為:/əpriɔri/--/e pe rui ao rui/
FP-Growth 英文發音為：/aif pi: grəuθ/--/F P-ge rou si/
前面一個詞一般讀中文普瑞奧瑞
后面的一個詞直接讀英文

用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

求用Matlab實現apriori算法關聯規則的挖掘程序,完整有詳細注解畢業設計要用的http://www.pudn.com/downloads355/sourcecode/math/detail1548181.html

誰有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

求個實現關聯規則挖掘的Apriori算法的代碼Apriori算法改進與實現研究
文章摘要：傳統的關聯規則挖掘的Apriori算法的時間開銷要大，建議挖掘ORAR的基于關系代數理論的關聯規則算法，不僅要掃描一次數據庫使用大量的模擬實驗證明改善關系matrix.Through ORAR算法是非常有效的，根據收集運行時間集中頻繁項減少大量開挖。
關鍵詞：Apriori算法; ORAR;改進;關系矩陣的關聯規則

在線急求apriori算法，要求能實現關聯規則摘要
隨著信息時代的發展，信息量呈幾何級數增長，人們發現從這些海量信息中獲取有用的信息越來越困難，要找出信息背后隱藏的規律更是不可想象。數據挖掘就是從大量數據中獲取有用信息的一門新技術，關聯規則挖掘是數據挖掘方法中的一種。本文詳細論述了基于Apriori算法的關聯規則挖掘系統的設計開發過程。系統基于經典的Apriori算法，對事務數據庫進行了位圖矩陣轉換，大大提高了搜索效率，并能分別挖掘頻繁項集和關聯規則。
論文組織如下：首先介紹了數據挖掘的產生、定義和應用；接著闡述了關聯規則挖掘的基本概念；然后對系統的需求進行了分析，并提出設計方案；緊接著是系統的具體實現；最后對系統進行了測試，將系統用于挖掘中藥方劑庫中的藥對藥組，驗證了系統的正確性和實用性。
關鍵詞：數據挖掘；關聯規則；Apriori算法

需求分析和設計方案
4.1需求分析
由于事務數據庫一般只具有對大量數據的存取、檢索功能，對于用戶的一般性的使用可以滿足，然而，正是由于數據庫中存放了大量的數據，不同的數據項，以及多個數據項之間還存在有大量的隱含的、未知的、有意義的數據關系，這些關系對于用戶有著及其重要的作用，所以數據挖掘便在此情況下產生了。而關聯規則挖掘是數據挖掘中一個重要規則，Apriori算法又是關聯挖掘的一個經典算法，它能發現大量數據中項集之間有趣的關聯和相關聯系。隨著大量數據不停地收集和存儲，許多業界人士對于從他們的數據庫中挖掘關聯規則越來越感興趣。從大量商務事務記錄中發現有趣的關聯關系，可以幫助許多商務決策的制定，如分類設計、交叉購物和促銷分析。

1引言
隨著數據庫技術的迅速發展以及數據庫管理系統的廣泛應用，人們積累的數據越來越多。激增的數據背后隱藏著許多重要的信息，人們希望能夠對其進行更高層次的分析，以便更好地利用這些數據。目前的數據庫系統可以高效地實現數據的錄入、查詢、統計等功能，但無法發現數據中存在的關系和規則，無法根據現有的數據預測未來的發展趨勢。缺乏找出數據背后隱藏的知識的手段，導致了“數據爆炸但知識貧乏”的現象。于是數據挖掘技術應運而生，并顯示出強大的生命力。數據挖掘就是從大量的、不完全的、有噪聲的、模糊的、隨機的數據中，提取隱含在其中的、人們事先不知道的、但又是潛在有用的信息和知識的過程。它使人類分析問題和發現知識能力得到了延伸。
2數據挖掘概述
2.1數據挖掘的產生
隨著信息時代的發展，信息量呈幾何級數增長，然而用于對這些數據進行分析處理的工具卻很少，人們擁有了海量的數據的同時卻苦于信息的缺乏。而激增的數據背后隱藏著許多重要的信息，人們希望能夠對其進行更高層次的分析，以便更好地利用這些數據。目前的數據庫系統可以高效地實現數據的錄入、查詢、統計等功能，但無法發現數據中存在的關系和規則，無法根據現有的數據預測未來的發展趨勢。缺乏挖掘數據背后隱藏的知識的手段，導致了“數據爆炸但知識貧乏”的現象。信息爆炸是一把雙刃劍：巨量的信息既是最重要的財富，又是最危險的殺手。巨量信息也導致決策與理解危機。面對“人人被數據淹沒，人們卻饑餓于知識”的挑戰，數據挖掘和知識發現技術應運而生，并得以蓬勃發展，越來越顯示出其強大的生命力。
數據挖掘是信息技術自然演化的結果。演化過程的見證是數據庫業界開發以下功能：數據收集和數據庫創建，數據管理（包括數據存儲和檢索，數據庫事務處理），以及數據分析與理解（涉及數據倉庫和數據挖掘）。例如，數據收集和數據庫創建機制的早期開發已成為稍后數據存儲和檢索、查詢和事務處理有效機制開發的必備基礎。隨著提供查詢和事務處理的大量數據庫系統廣泛付諸實踐，數據分析和理解自然成為下一個目標。
2.2數據挖掘的定義
數據挖掘是從大量數據中提取或“挖掘”知識。具體來說，數據挖掘就是從大量的、不完全的、有噪聲的、模糊的、隨機的數據中，提取隱含在其中的、人們事先不知道的、但又是潛在有用的信息和知識的過程。
人們把原始數據看作是形成知識的源泉，就像從礦石中采礦一樣。原始數據有結構化的，如關系數據庫中的數據，也有半結構化的，如文本、圖形、圖像數據，甚至是分布在網絡上的異構型數據。發現知識的方法可以是數學的，也可以是非數學的;可以是演繹的，也可以是歸納的。發現了的知識可以被用于信息管理、查詢優化、決策支持、過程控制等，還可以用于數據自身的維護。因此，數據挖掘是一門很廣義的交叉學科，它匯聚了不同領域的研究者，尤其是數據庫、人工智能、數理統計、可視化、并行計算等方面的學者和工程技術人員。
數據挖掘使用復雜的統計分析和建模技術來揭示企業數據庫中隱藏的模式與關系——而這些模式是有可能被普通的方法所忽略的。數據挖掘從數據的分析入手、幫助決策，能從數據中尋找有價值的規律的技術。同時它也代表一個分析過程，我們具體化為方法學。實際上，數據庫中的知識發現是一門交叉性學科，涉及到機器學習、模式識別、統計學、智能數據庫、知識獲取、數據可視化、高性能計算、專家系統等多個領域。從數據庫中發現出來的知識可以用在信息管理、過程控制、科學研究、決策支持等許多方面。
特別要指出的是，數據挖掘技術從一開始就是面向應用的。它不僅是面向特定數據庫的簡單檢索查詢調用，而且要對這些數據進行微觀、中觀乃至宏觀的統計、分析、綜合和推理，以指導實際問題的求解，企圖發現事件間的相互關聯，甚至利用已有的數據對未來的活動進行預測。
許多人把數據挖掘視為另一個常用的術語數據庫中的知識發現或KDD (knowledge discovery in databases)的同義詞。而另一些人只是把數據挖掘視為數據庫中知識發現過程的一個基本步驟。知識發現過程如圖1所示，由以下步驟組成：
1) 數據清理（消除噪聲或不一致數據）
2) 數據集成（多種數據源可以組合在一起）
3) 數據選擇（從數據庫中檢索與分析任務相關的數據）
4) 數據變換（數據變換或統一成適合挖掘的形式，如通過匯總或聚集操作）
5) 數據挖掘（基本步驟，使用智能方法提取數據模式）
6) 模式評估（根據某種興趣度度量，識別出真正有趣的模式）
7) 知識表示（使用可視化和知識表示技術，向用戶提供挖掘的知識）