关联规则挖掘之算法实现

一： A Priori的基础实现

算法：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;

    首先来看一个频繁集的性质。
   定理：如果项目集X是频繁集，那么它的非空子集都是频繁集。
根据定理，已知一个k-频繁集的项集X，X的所有k-1阶子集都肯定是频繁集，也就肯定可以找到两个k-1频繁集的项集，它们只有一项不同，且连接后等于X。这证明了通过连接k-1频繁集产生的k-候选集覆盖了k-频繁集。同时，如果k-候选集中的项集Y，包含有某个k-1阶子集不属于k-1频繁集，那么Y就不可能是频繁集，应该从候选集中裁剪掉。Apriori算法就是利用了频繁集的这个性质。
step1: join, 连接k-1频繁集产生的k-候选集覆盖了k-频繁集。
step2: prune, 如果k-候选集中的项集Y，包含有某个k-1阶子集不属于k-1频繁集，那么Y就不可能是频繁集，应该从候选集中裁剪掉。
  

	/*construct C3...................................................*/
	vector<Node3> c3;
	vector<Node3> l3;

	vector<Node2>::iterator ite31=l2.begin();//iter 31,32
	for(;ite31!=l2.end();ite31++)
	{
		vector<Node2>::iterator ite32=l2.begin();
		for(;ite32!=l2.end();ite32++)
		{
			if(ite31->index_j == ite32->index_i) //step1:找到两个k-1频繁集的项集，它们只有一项不同，且连接后等于X
			{
					vector<Node2>::iterator ite33=l2.begin();
					for(;ite33!=l2.end();ite33++)
					{
						/*step2:如果k-候选集中的项集Y，包含有某个k-1阶子集不属于k-1频繁集，那么Y就不可能是频繁集，应该从候选集中裁剪掉*/
						if(ite33->index_i == ite31->index_i && ite33->index_j ==ite32->index_j)
						{
										Node3 n3(ite31->index_i,ite31->index_j,ite32->index_j,0);
										c3.push_back(n3);
						}
					}
			}

		}
	}

      如果不同的k-候选集的最小支持度是相同的，那么并不需要上述中的第二步的prune操作。因为在接下来的扫描D的步骤中是可以裁减掉他的不满足条件的子集的。 如ab+bc=abc, 已知ab和bc已经是k-1介子集，那么如果abc达到了2次的最小支持度，可以成为频繁项集，那么一定会有ac也达到至少2次的支持度。只是如果随着k的增加，最小支持度减少，就必须在k-1介子集中去修剪。

   如下是A Priori算法的实现。计算到了L3。

<pre name="code" class="cpp"><pre name="code" class="cpp">/* 这个程序是数据挖掘中的Apriori算法 
	Apriori算法的描述
	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*/

#include <stdio.h> 
#include<string.h>  
#include <iostream>
#include <vector>
#include <algorithm>
#define D 9 /*D数事务的个数*/  
#define MinSupCount 2 /*最小事务支持度数*/  
#define ItemN 5
using namespace std;

int hash1(char c)
{
	return (int)c-(int)'a';
}
class Node1
{
public:
	int index_i;
	int count;
	Node1()
	{
		index_i=-1;
		count=0;
	}
	Node1(int i, int c):index_i(i),count(c)
	{
	}
};
class Node2
{
public:
	int index_i;
	int index_j;
	int count;
	Node2()
	{
		index_i=-1;
		index_j=-1;
		count = 0;
	}
		Node2(int i, int j, int c):index_i(i),index_j(j),count(c)
	{
	}
};
class Node3
{
public:
	int index_i;
	int index_j;
	int index_k;
	int count;
	Node3()
	{
		index_i=-1;
		index_j=-1;
		index_k=-1;
		count =0;
	}
	Node3(int i, int j, int k, int c):index_i(i),index_j(j),index_k(k), count(c)
	{
	}
};

void printNode3(vector<Node3>& n3)
{
	vector<Node3>::iterator ite = n3.begin();
	for(;ite!=n3.end();ite++)
	{
		cout<<(char)(ite->index_i+'a')<<(char)(ite->index_j+'a')<<(char)(ite->index_k+'a')<<":"<<ite->count<<"\t";
	}
	cout<<endl;
}
void printNode2(vector<Node2>& n2)
{
	vector<Node2>::iterator ite = n2.begin();
	for(;ite!=n2.end();ite++)
	{
		cout<<(char)(ite->index_i+'a')<<(char)(ite->index_j+'a')<<":"<<ite->count<<"\t";
	}
	cout<<endl;
}
void printNode1(vector<Node1>& n1)
{
	vector<Node1>::iterator ite = n1.begin();
	for(;ite!=n1.end();ite++)
	{
		cout<<(char)(ite->index_i+'a')<<":"<<ite->count<<"\t";
	}
	cout<<endl;
}

void main() 
{  
	/*这里的a,b,c,d,e 分别代表着书上数据挖掘那章的I1,I2,I3,I4,I5 */     
	char a[10][10]={   
		{'a','b','e'},   
		{'b','d'},   
		{'b','c'},   
		{'a','b','d'},   
		{'a','c'},   
		{'b','c'},   
		{'a','c'},   
		{'a','b','c','e'},   
		{'a','b','c'}  
	};   //total is D   

	/*c1, hash the first time to b*/
	//at first. hash the value
    vector<Node1> l1;
    int b[10]={0};
	int  ItemNumber=0;
	for(int i=0;i<D;i++)     
	{          
		for(int j=0;a[i][j]!='\0';j++)         
		{ 
			int item = hash1(a[i][j]);
			if(b[item]==0)
			{
				b[item]++;
				ItemNumber++;
			}
			else
			{				
				b[item]++;
			}
        
		}     
	}
	/*L1........................................................*/
	for(int i=0;i<ItemNumber;i++)     
	{          
		if(b[i]>=MinSupCount)         
		{ 
			Node1 n1(i,b[i]);
			l1.push_back(n1);
		}
	}
	cout<<"print L1................................................"<<endl;
	printNode1(l1);
     
	
	/*construct c2...........................................................*/
	vector<Node2> c2;
	vector<Node2>l2;
	vector<Node1>::iterator ite21=l1.begin(); //ite21,22
	for(;ite21!=l1.end();ite21++)
	{
		vector<Node1>::iterator ite22=l1.begin();
		for(;ite22!=l1.end();ite22++)
		{
			if(ite22->index_i > ite21->index_i)
			{
				Node2 n2(ite21->index_i,ite22->index_i,0);
				c2.push_back(n2);
			}
		}
	}
	/*count C2.........................................................................*/
	for(int k=0;k<D;k++)
	{
		for(int i=0;a[k][i]!='\0';i++)
		{
			int h1 = hash1(a[k][i]);
			for(int j=i+1;a[k][j]!='\0';j++)
			{
				int h2=hash1(a[k][j]);
	
				vector<Node2>::iterator ite=c2.begin();
				for(;ite!=c2.end();ite++)
				{
					if(ite->index_i ==h1 && ite->index_j == h2)
						ite->count++;
				}
			}
		}
	}
	/*prune C2 to L2.......................................................*/
	l2.clear();
	vector<Node2>::iterator ite2=c2.begin(); //ite2
	for(;ite2!=c2.end();ite2++)
	{
		if(ite2->count>=MinSupCount)
		{
			l2.push_back(*ite2);
		}
	}
	cout<<"print L2............................................"<<endl;
	printNode2(l2);
		/*construct C3...................................................*/
	vector<Node3> c3;
	vector<Node3> l3;

	vector<Node2>::iterator ite31=l2.begin();//iter 31,32
	for(;ite31!=l2.end();ite31++)
	{
		vector<Node2>::iterator ite32=l2.begin();
		for(;ite32!=l2.end();ite32++)
		{

			if(ite31->index_j == ite32->index_i)
			{
				Node3 n3(ite31->index_i,ite31->index_j,ite32->index_j,0);
				c3.push_back(n3);
			}

		}
	}
	/*countC3.................................................*/
	for(int out=0;out<D;out++)
	{
		for(int i=0;a[out][i]!='\0';i++)
		{
			int h1 = hash1(a[out][i]);
			for(int j=i+1;a[out][j]!='\0';j++)
			{
				int h2=hash1(a[out][j]);
				for(int k=j+1;a[out][k]!='\0';k++)
				{
					int h3=hash1(a[out][k]);
					vector<Node3>::iterator ite=c3.begin();
					for(;ite!=c3.end();ite++)
					{
						if(ite->index_i ==h1 && ite->index_j == h2 && ite->index_k==h3)
						ite->count++;
					}
				}
	
			}
		}
	}
	/*prune C3 to l3....................................*/
	l3.clear();
	vector<Node3>::iterator ite3=c3.begin(); //ite3
	for(;ite3!=c3.end();ite3++)
	{
		if(ite3->count>=MinSupCount)
		{
			l3.push_back(*ite3);
		}
	}
	cout<<"print L3..........................."<<endl;
	printNode3(l3);
	system("pause");
}

下面是代码的结果：