關聯挖掘演算法

A. 帶你了解數據挖掘中的經典演算法

數據挖掘的演算法有很多，而不同的演算法有著不同的優點，同時也發揮著不同的作用。可以這么說，演算法在數據挖掘中做出了極大的貢獻，如果我們要了解數據挖掘的話就不得不了解這些演算法，下面我們就繼續給大家介紹一下有關數據挖掘的演算法知識。
1.The Apriori algorithm，
Apriori演算法是一種最有影響的挖掘布爾關聯規則頻繁項集的演算法。其核心是基於兩階段頻集思想的遞推演算法。該關聯規則在分類上屬於單維、單層、布爾關聯規則。在這里，所有支持度大於最小支持度的項集稱為頻繁項集，簡稱頻集。這個演算法是比較復雜的，但也是十分實用的。
2.最大期望演算法
在統計計算中，最大期望演算法是在概率模型中尋找參數最大似然估計的演算法，其中概率模型依賴於無法觀測的隱藏變數。最大期望經常用在機器學習和計算機視覺的數據集聚領域。而最大期望演算法在數據挖掘以及統計中都是十分常見的。
3.PageRank演算法
PageRank是Google演算法的重要內容。PageRank里的page不是指網頁，而是創始人的名字，即這個等級方法是以佩奇來命名的。PageRank根據網站的外部鏈接和內部鏈接的數量和質量倆衡量網站的價值。PageRank背後的概念是，每個到頁面的鏈接都是對該頁面的一次投票，被鏈接的越多，就意味著被其他網站投票越多。這個就是所謂的「鏈接流行度」，這個標准就是衡量多少人願意將他們的網站和你的網站掛鉤。PageRank這個概念引自學術中一篇論文的被引述的頻度——即被別人引述的次數越多，一般判斷這篇論文的權威性就越高。
3.AdaBoost演算法
Adaboost是一種迭代演算法，其核心思想是針對同一個訓練集訓練不同的分類器，然後把這些弱分類器集合起來，構成一個更強的最終分類器。其演算法本身是通過改變數據分布來實現的，它根據每次訓練集之中每個樣本的分類是否正確，以及上次的總體分類的准確率，來確定每個樣本的權值。將修改過權值的新數據集送給下層分類器進行訓練，最後將每次訓練得到的分類器最後融合起來，作為最後的決策分類器。這種演算法給數據挖掘工作解決了不少的問題。
數據挖掘演算法有很多，這篇文章中我們給大家介紹的演算法都是十分經典的演算法，相信大家一定可以從中得到有價值的信息。需要告訴大家的是，我們在進行數據挖掘工作之前一定要事先掌握好數據挖掘需呀掌握的各類演算法，這樣我們才能在工總中得心應手，如果基礎不牢固，那麼我們遲早是會被淘汰的。職場如戰場，我們一定要全力以赴。

B. 加權關聯規則挖掘方法，哪位大神能將下面的偽代碼轉為java代碼

有沒有加權FP-tree的研究啊，向下封閉性怎麼證明

C. 怎樣生成數據挖掘的數據集,使用數據集進行關聯規則Apriori演算法，只想要純數據集，我想用VF編程實現挖掘。

當你把整個文件打開的時候說明文件已經被load到內存里了。所以請檢查你的內存是否夠大，或者虛擬內存太小。 按理來說T10I4D100K.dat是很小的一個文件，雖然有10W行，但寬度很小啊。 建議你把虛擬內存調大一點，關閉其他佔用大量內存的程序，例如IE，等等。 再么就是看看你的程序是否設計合理。這點兒數據根本不能算做大數據集。 over!

D. 數據挖掘中的Hotspot關聯規則

提到關聯規則演算法，一般會想到Apriori或者FP，一般很少有想到HotSpot的，這個演算法不知道是應用少還是我查資料的手段太low了，在網上只找到很少的內容，這篇http://wiki.pentaho.com/display/DATAMINING/HotSpot+Segmentation-Profiling ，大概分析了一點，其他好像就沒怎麼看到了。比較好用的演算法類軟體，如weka，其裡面已經包含了這個演算法，在Associate--> HotSpot裡面即可看到，運行演算法界面一般如下：

其中，紅色方框裡面為設置的參數，如下：

-c last ，表示目標所在的目標所在的列，last表示最後一列，也是是數值，表示第幾列；

-V first， 表示目標列的某個狀態值下標值（這里可以看出目標列應該是離散型），first表示第0個，可以是數值型；

-S 0.13，最小支持度，裡面會乘以樣本總數得到一個數值型的支持度；

-M 2 ， 最大分指數；

-I 0.01 ， 在weka裡面解釋為Minimum improvement in target value，不知道是否傳統的置信度一樣；

相關說明：本篇相關代碼參考weka裡面的HotSpot演算法的具體實現，本篇只分析離散型數據，代碼可以在（http://download.csdn.net/detail/fansy1990/8488971）下載。

1. 數據：

@attribute age {young, pre-presbyopic, presbyopic}
@attribute spectacle-prescrip {myope, hypermetrope}
@attribute astigmatism {no, yes}
@attribute tear-prod-rate {reced, normal}
@attribute contact-lenses {soft, hard, none}
young,myope,no,reced,none
young,myope,no,normal,soft
young,myope,yes,reced,none
。。。
presbyopic,hypermetrope,yes,normal,none
這個數據格式是參考weka裡面的，加入最前面的5行是因為需要把各個屬性進行編碼，所以提前拿到屬性的各個狀態，方便後續操作；
2. 單個節點定義：
public class HSNode {
private int splitAttrIndex; // 屬性的下標
private int attrStateIndex; // 屬性state的下標
private int allCount ; // 當前數據集的個數
private int stateCount ; // 屬性的state的個數
private double support; // 屬性的支持度
private List<HSNode> chidren;

public HSNode(){}}

splitAttrIndex 即對應屬性astigmatism的下標（應該是第2個，從0開始）；attrStateIndex 則對應這個屬性的下標，即no的下標（這里應該是0）；allCount即12，stateCount即5，support 對應41.57%（即5/12的值）；children即其孩子節點；（這里的下標即是從文件的前面幾行編碼得到的，比如屬性age為第一個屬性，編碼為0，young為其第一個狀態，編碼為0）；

3. 演算法偽代碼，（文字描述，太不專業了，如果要看，就將就看？）

1. 創建根節點；
2. 創建孩子節點；

2.1 針對所有數據，計算每列的每個屬性的』支持度『support，
if support>= MINSUPPORT
把該列的當前屬性加入潛在的孩子節點列表；
end
2.2 針對潛在孩子節點列表遍歷
if (!當前節點產生的規則序in全局規則序列）
把當前節點加入孩子節點列表；
把當前節點產生的規則加入全局規則中；
end

2.3 遍歷孩子節點列表
針對當前節點，返回到2，進行遞歸；

4. 代碼關鍵步驟具體實現：

4.1 數據讀取及初始化：

1） 讀取文件的前面幾行，初始化兩個變數，attributes和attributeStates ,分別對應所有的屬性和屬性的各個狀態；

while ((tempString = reader.readLine()) != null) {
// 第一行數據是標題
if(tempString.indexOf(HSUtils.FILEFORMAT)==0){
String attr = tempString.substring(HSUtils.FILEFORMAT.length()
, tempString.indexOf("{")).trim();
String[] attrStates =tempString.substring(tempString.indexOf("{")+1,
tempString.indexOf("}")).split(",");
for(int i=0;i<attrStates.length;i++){
attrStates[i]=attrStates[i].trim();
}
attrList.add( attr);
line++;
this.attributeStates.put(attr, attrStates);
continue;
}
if(flag){
this.attributes= new String[line];
attrList.toArray(this.attributes);// 復制值到數組中
flag=false;
}
String[] tempStrings = tempString.split(splitter);
lists.add(strArr2IntArr(tempStrings));
}
2） 後面就是把下面的數據轉為數值型數組了，strArr2IntArr 函數如下：
/**
* String 數組轉為int數組
* @param sArr
* @return
* @throws Exception
*/
private int[] strArr2IntArr(String[] sArr) throws Exception{
int[] iArr = new int[sArr.length];
for(int i=0;i<sArr.length;i++){
iArr[i]= getAttrCode(sArr[i],i);
}
return iArr;
}
/**
* 獲得第attrIndex屬性的attrState的編碼
* @param attrState
* @param attrIndex
* @return
* @throws Exception
*/
private int getAttrCode(String attrState,int attrIndex) throws Exception{
String[] attrStates = attributeStates.get(attributes[attrIndex]);
for(int i=0;i<attrStates.length;i++){
if(attrState.equals(attrStates[i])){
return i;
}
}
throw new Exception("編碼錯誤！");
// return -1; // 如果運行到這里應該會報錯
}

這里數據讀取主要是把離散型的字元串類型數據轉換為數值型數據，編碼規則如下：

屬性age的狀態： [young-->0,pre-presbyopic-->1,presbyopic-->2,]
屬性spectacle-prescrip的狀態： [myope-->0,hypermetrope-->1,]
屬性astigmatism的狀態： [no-->0,yes-->1,]
屬性tear-prod-rate的狀態： [reced-->0,normal-->1,]
屬性contact-lenses的狀態： [soft-->0,hard-->1,none-->2,]
4.2 初始化根節點

// 讀取文件並賦值
List<int[]> intData = readFileAndInitial(HSUtils.FILEPATH,HSUtils.SPLITTER);;

int splitAttributeIndex = attributes.length-1;// 下標需減1
int stateIndex = HSUtils.LABELSTATE;

int numInstances = intData.size();// 數據總個數
int[] labelStateCount = attrStateCount(intData,attributes.length-1);

HSUtils.setMinSupportCount(numInstances);
double targetValue=1.0*labelStateCount[HSUtils.LABELSTATE]/numInstances;
// 創建根節點
HSNode root = new HSNode(splitAttributeIndex,stateIndex,labelStateCount[stateIndex],numInstances);
double[] splitVals=new double[attributes.length];
byte[] tests = new byte[attributes.length];
root.setChidren(constructChildrenNodes(intData,targetValue,splitVals,tests));
labelStateCount即目標屬性的各個狀態的個數，比如這里目標狀態為soft，一共有5個值，一共有24個樣本，所以其支持度為5/25=20.82%;
constructChildrenNodes函數為創建所有子節點，接收的參數有：intData：所有的數據（經過編碼的）；targetValue：當前節點支持度；splitVals和tests數組主要用於針對節點產生規則；

4.3 創建孩子節點：

1） 計算潛在孩子節點：

private List<HSNode> constructChildrenNodes(List<int[]> intData,double targetValue,
double[] splitVals,
byte[] tests) {

// 設置孩子節點
// // 獲取子數據集
//
// 針對每個屬性的每個state值計算其支持度（需要符合置信度）
PriorityQueue<AttrStateSup> pq = new PriorityQueue<AttrStateSup>();
for(int i=0;i<attributes.length-1;i++){// 最後一個屬性不用計算（為Label）
evaluateAttr(pq,intData,i,targetValue);
}
這里的evaluateAttr主要是判斷每個屬性的各個狀態是否符合要求，是則加入pq

/**
* 是否把第attrIndex屬性的state作為備選節點加入pq
* @param pq
* @param intData
* @param attrIndex
* @param targetValue
* @param stateIndex
* @param labelStateCount
*/
private void evaluateAttr(PriorityQueue<AttrStateSup> pq,
List<int[]> intData, int attrIndex, double targetValue) {
int[] counts = attrStateCount(intData,attrIndex);

boolean ok = false;
// only consider attribute values that result in subsets that meet/exceed min support
for (int i = 0; i < counts.length; i++) {
if (counts[i] >= HSUtils.getMinSupportCount()) {
ok = true;
break;
}
}
if(ok){
double subsetMatrix =0.0;
for(int stateIndex=0;stateIndex<counts.length;
stateIndex++){
subsetMatrix =attrStateCount(intData,attrIndex,stateIndex,attributes.length-1,HSUtils.LABELSTATE);
if(counts[stateIndex]>=HSUtils.getMinSupportCount()&&subsetMatrix>=HSUtils.getMinSupportCount()){

double merit = 1.0*subsetMatrix / counts[stateIndex]; //
double delta = merit - targetValue;
if(delta/targetValue>=HSUtils.MINCONFIDENCE){
pq.add(new AttrStateSup(attrIndex,stateIndex,counts[stateIndex],(int)subsetMatrix));
}

}
}
}// ok
}

這里首先針對當前數據集計算屬性下標為attrIndex的各個狀態的計數到counts[]數組中；如果各個狀態的所有計數都小於最小支持度，則該屬性都不作為備選加入pq中；否則繼續判斷：計算目標屬性的設定狀態（比如soft）和當前屬性的狀態（young）共同出現的次數（第一次應該是2），賦值給subsetMatrix（那麼該值就是2）；判斷subsetMatrix是否>=最小支持度，如果是在按照上面的代碼進行計算，最後還有個判斷是用到置信度的（暫譯為置信度），如果滿足則把其加入到pq中，即備選子節點列表；
2）生成全局規則，並添加孩子節點

List<HSNode> children = new ArrayList<HSNode>();
List<HotSpotHashKey> keyList = new ArrayList<HotSpotHashKey>();
while(pq.size()>0&&children.size()<HSUtils.MAXBRANCH){
AttrStateSup attrStateSup = pq.poll();

// 再次進行過濾
double[] newSplitVals = splitVals.clone();
byte[] newTests = tests.clone();
newSplitVals[attrStateSup.getAttrIndex()]=attrStateSup.getStateIndex()+1;
newTests[attrStateSup.getAttrIndex()] =(byte)2;

HotSpotHashKey key = new HotSpotHashKey(newSplitVals, newTests);
if (!HSUtils.m_ruleLookup.containsKey(key)) {
// insert it into the hash table
HSUtils.m_ruleLookup.put(key, ""); // 需要先增加規則，然後才處理子節點
HSNode child_i= new HSNode(attrStateSup.getAttrIndex(),attrStateSup.getStateIndex(),
attrStateSup.getStateCount(),attrStateSup.getAllCount());
keyList.add(key);
children.add(child_i);
} else {
System.out.println("The potential ,but not included :"+attrStateSup);
}
}
這里的全局規則使用HotSpotHashKey生成，具體規則的含義沒有理解（可能和演算法原理有關，都找不到一篇相關的paper！）
添加一個節點後，就會添加相應的規則，這樣可以避免孩子節點的孩子有相同的規則被重復添加；

3） 針對每個孩子節點，處理其節點的孩子

// 處理子節點
for(int i=0;i<children.size();i++){
HSNode child = children.get(i);
child.setChidren(constructChildrenNodes(getSubData(intData,child.getSplitAttrIndex(),
child.getAttrStateIndex()),child.getSupport(),keyList.get(i).getM_splitValues(),
keyList.get(i).getM_testTypes()));

}
這里使用遞歸進行調用，方便處理。需注意節點規則的生成使用的兩個數組newSplitValues 和newTests需要往下傳遞，所以在每個孩子節點生成規則的時候把其加入到一個keyList，這樣在遍歷孩子節點，處理其節點的孩子時，可以找到對應的規則傳遞數組；

這里的getSubData即是找到當前數據集中和給定的屬性下標即屬性狀態一樣的數據返回，如下：

/**
* 獲取和splitAttributeIndex相同下標的屬性以及stateIndex的所有數據
* @param intData
* @param splitAttributeIndex
* @param stateIndex
* @return
*/
private List<int[]> getSubData(List<int[]> intData,
int splitAttributeIndex, int stateIndex) {
List<int[]> subData = new ArrayList<int[]>();
for(int[] d:intData){
if(d[splitAttributeIndex]==stateIndex){
subData.add(d);
}
}
return subData;
}

4.4 列印規則樹

/**
* 列印規則樹
* @param node
* @param level
*/
public void printHSNode(HSNode node,int level){
printLevelTab(level);
System.out.print(node+"\n");

List<HSNode> children= node.getChidren();
for(HSNode child:children){
printHSNode(child,level+1);
}
}
private void printLevelTab(int level) {
for(int i=0;i<level;i++){
System.out.print("|\t");
}
}
這里可以看到針對當前節點，使用直接列印的方式，因為這里覆寫了toString方法，所以可以這樣，其toString 方法如下：

/**
* 格式化輸出
*/
public String toString(){
return HSUtils.getAttr(this.splitAttrIndex)+"="+HSUtils.getAttrState(splitAttrIndex, attrStateIndex)
+" ("+HSUtils.formatPercent(this.support)+" ["+this.stateCount+"/"+this.allCount+"])";
}

4.5 演算法調用：

package fz.hotspot;

import fz.hotspot.dataobject.HSNode;

public class HotSpotTest {

/**
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
String file = "D:/jars/weka-src/data/contact-lenses.txt";
int labelStateIndex = 0; // 目標屬性所在下標
int maxBranches=2; // 最大分支數目
double minSupport =0.13; // 最小支持度
double minConfidence=0.01;// 最小置信度（在weka中使用的是minImprovement）
HotSpot hs = new HotSpot();
HSNode root = hs.run(file,labelStateIndex,maxBranches,minSupport,minConfidence);
System.out.println("\n規則樹如下：\n");
hs.printHSNode(root,0);
}

}
列印的規則樹如下：

contact-lenses=soft (20.83% [5/24])
| astigmatism=no (41.67% [5/12])
| | tear-prod-rate=normal (83.33% [5/6])
| | | spectacle-prescrip=hypermetrope (100.00% [3/3])
| | spectacle-prescrip=hypermetrope (50.00% [3/6])
| tear-prod-rate=normal (41.67% [5/12])
| | spectacle-prescrip=hypermetrope (50.00% [3/6])

可以看到和weka給出的是一致的。

最近在看《暗時間》，上面提到說有想法最好寫下來，這樣不僅可以加深自己的理解，同時在寫的過程中，比如一些表達之類的 也可以加強（身為程序員，這方面的能力確實欠缺），同時也可以讓別人檢驗到自己的思維盲點。

文中相關演算法理解，僅代表自己觀點。

分享，成長，快樂

腳踏實地，專注

轉載請註明blog地址：http://blog.csdn.net/fansy1990

文章最後發布於: 2015-03-10
版權聲明：本文為博主原創文章，遵循 CC 4.0 BY-SA 版權協議，轉載請附上原文出處鏈接和本聲明。
本文鏈接：https://blog.csdn.net/fansy1990/article/details/44177523
展開全文

E. 數據挖掘演算法有哪些

統計和可視化要想建立一個好的預言模型，你必須了解自己的數據。最基本的方法是計算各種統計變數（平均值、方差等）和察看數據的分布情況。你也可以用數據透視表察看多維數據。數據的種類可分為連續的，有一個用數字表示的值（比如銷售量）或離散的，分成一個個的類別（如紅、綠、藍）。離散數據可以進一步分為可排序的，數據間可以比較大小（如，高、中、低）和標稱的，不可排序（如郵政編碼）。圖形和可視化工具在數據准備階段尤其重要，它能讓你快速直觀的分析數據，而不是給你枯燥乏味的文本和數字。它不僅讓你看到整個森林，還允許你拉近每一棵樹來察看細節。在圖形模式下人們很容易找到數據中可能存在的模式、關系、異常等，直接看數字則很難。可視化工具的問題是模型可能有很多維或變數，但是我們只能在2維的屏幕或紙上展示它。比如，我們可能要看的是信用風險與年齡、性別、婚姻狀況、參加工作時間的關系。因此，可視化工具必須用比較巧妙的方法在兩維空間內展示n維空間的數據。雖然目前有了一些這樣的工具，但它們都要用戶「訓練」過他們的眼睛後才能理解圖中畫的到底是什麼東西。對於眼睛有色盲或空間感不強的人，在使用這些工具時可能會遇到困難。聚集（分群）聚集是把整個資料庫分成不同的群組。它的目的是要群與群之間差別很明顯，而同一個群之間的數據盡量相似。與分類不同（見後面的預測型數據挖掘），在開始聚集之前你不知道要把數據分成幾組，也不知道怎麼分（依照哪幾個變數）。因此在聚集之後要有一個對業務很熟悉的人來解釋這樣分群的意義。很多情況下一次聚集你得到的分群對你的業務來說可能並不好，這時你需要刪除或增加變數以影響分群的方式，經過幾次反復之後才能最終得到一個理想的結果。神經元網路和K-均值是比較常用的聚集演算法。不要把聚集與分類混淆起來。在分類之前，你已經知道要把數據分成哪幾類，每個類的性質是什麼，聚集則恰恰相反。關聯分析關聯分析是尋找資料庫中值的相關性。兩種常用的技術是關聯規則和序列模式。關聯規則是尋找在同一個事件中出現的不同項的相關性，比如在一次購買活動中所買不同商品的相關性。序列模式與此類似，他尋找的是事件之間時間上的相關性，如對股票漲跌的分析。關聯規則可記為A==>B，A稱為前提和左部（LHS），B稱為後續或右部（RHS）。如關聯規則「買錘子的人也會買釘子」，左部是「買錘子」，右部是「買釘子」。要計算包含某個特定項或幾個項的事務在資料庫中出現的概率只要在資料庫中直接統計即可。某一特定關聯（「錘子和釘子」）在資料庫中出現的頻率稱為支持度。比如在總共1000個事務中有15個事務同時包含了「錘子和釘子」，則此關聯的支持度為1.5%。非常低的支持度（比如1百萬個事務中只有一個）可能意味著此關聯不是很重要，或出現了錯誤數據（如，「男性和懷孕」）。要找到有意義的規則，我們還要考察規則中項及其組合出現的相對頻率。當已有A時，B發生的概率是多少？也即概率論中的條件概率。回到我們的例子，也就是問「當一個人已經買了錘子，那他有多大的可能也會買釘子？」這個條件概率在數據挖掘中也稱為可信度，計算方法是求百分比：（A與B同時出現的頻率）/（A出現的頻率）。讓我們用一個例子更詳細的解釋這些概念： 總交易筆數（事務數）：1,000包含「錘子」：50包含「釘子」：80包含「鉗子」：20包含「錘子」和「釘子」：15包含「鉗子」和「釘子」：10包含「錘子」和「鉗子」：10包含「錘子」、「鉗子」和「釘子」：5 則可以計算出： 「錘子和釘子」的支持度=1.5%（15/1,000）「錘子、釘子和鉗子」的支持度=0.5%（5/1,000）「錘子==>釘子」的可信度=30%（15/50）「釘子==>錘子」的可信度=19%（15/80）「錘子和釘子==>鉗子」的可信度=33%（5/15）「鉗子==>錘子和釘子」的可信度=25%（5/20）

F. 數據挖掘的關聯規則算是分類演算法么

不是的。分類演算法就訓練好一個模型，然後根據模型判斷新紀錄的分類情況。而關聯規則則是發現紀錄中屬性之間的關聯程度

G. 數據挖掘關聯規則演算法如何做模擬實驗急呀!

當你把整個文件打開的時候說明文件已經被load到內存里了。所以請檢查你的內存是否夠大，或者虛擬內存太小。

按理來說T10I4D100K.dat是很小的一個文件，雖然有10W行，但寬度很小啊。

建議你把虛擬內存調大一點，關閉其他佔用大量內存的程序，例如IE，等等。

再么就是看看你的程序是否設計合理。這點兒數據根本不能算做大數據集。

over!

H. 常用的數據挖掘演算法有哪幾類

常用的數據挖掘演算法分為以下幾類：神經網路，遺傳演算法，回歸演算法，聚類分析演算法，貝耶斯演算法。

目前已經進入大數據的時代，所以數據挖掘和大數據分析的就業前景非常好，學好大數據分析和數據挖掘可以在各個領域中發揮自己的價值；同時，大數據分析並不是一蹴而就的事情，而是需要你日積月累的數據處理經驗，不是會被輕易替代的。一家公司的各項工作，基本上都都用數據體現出來，一位高級的數據分析師職位通常是數據職能架構中領航者，擁有較高的分析和思辨能力，對於業務的理解到位，並且深度知曉公司的管理和商業行為，他可以負責一個子產品或模塊級別的項目，帶領團隊來全面解決問題，把控手下數據分析師的工作質量。

想要了解更多有關數據挖掘演算法的信息，可以了解一下CDA數據分析師的課程。課程教你學企業需要的敏捷演算法建模能力，可以學到前沿且實用的技術，挖掘數據的魅力;教你用可落地、易操作的數據科學思維和技術模板構建出優秀模型，只教實用干貨，以專精技術能力提升業務效果與效率。點擊預約免費試聽課。