电子发烧友App
一、关联算法简介
关联规则的目的在于在一个数据集中找出项之间的关系，也称之为购物蓝分析 （market basketanalysis）。例如，购买鞋的顾客，有10%的可能也会买袜子，60%的买面包的顾客，也会买牛奶。这其中最有名的例子就是“尿布和啤酒”的故事了。关联规则的应用场合。在商业销售上，关联规则可用于交叉销售，以得到更大的收入；在保险业务方面，如果出现了不常见的索赔要求组合，则可能为欺诈，需要作进一步的调查。在医疗方面，可找出可能的治疗组合；在银行方面，对顾客进行分析，可以推荐感兴趣的服务等等。Apriori algorithm是关联规则里一项基本算法。
二、关联算法的基本原理
该算法的基本思想是：首先找出所有的频集，这些项集出现的频繁性至少和预定义的最小支持度一样。然后由频集产生强关联规则，这些规则必须满足最小支持度和最小可信度。然后使用第1步找到的频集产生期望的规则，产生只包含集合的项的所有规则，其中每一条规则的右部只有一项，这里采用的是中规则的定义。一旦这些规则被生成，那么只有那些大于用户给定的最小可信度的规则才被留下来。为了生成所有频集，使用了递推的方法
三、关联算法的C++简单实现
（1）算法数据：
对给定数据集用Apriori算法进行挖掘，找出其中的频繁集并生成关联规则。对下面数据集进行挖掘：
对于数据集，取最小支持度minsup=2，最小置信度minconf=0.8。
（2）算法步骤：
① 首先单趟扫描数据集，计算各个一项集的支持度，根据给定的最小支持度闵值，得到一项频繁集L1。
② 然后通过连接运算，得到二项候选集，对每个候选集再次扫描数据集，得出每个候选集的支持度，再与最小支持度比较。得到二项频繁集L2。
③ 如此进行下去，直到不能连接产生新的候选集为止。
④ 对于找到的所有频繁集，用规则提取算法进行关联规则的提取。
（3）C++算法的简单实现
①首先要在工程名文件夹里自己定义date.txt文档存放数据，然后在main函数中用FILE* fp=fopen（“date.txt”，“r”）;将数据导入算法。
②定义int countL1［10］;找到各一维频繁子集出现的次数。
定义char curL1［20］［2］;实现出现的一维子集。
由于给出的数据最多有4个数，所以同样的我们要定义到4维来放数据。
int countL2［10］; //各二维频繁子集出现的次数
char curL2［20］［3］; //出现的二维子集
int countL3［10］; //各三维频繁子集出现的次数
char curL3［20］［4］; //出现的三维子集
char cur［50］［4］;
③定义int SizeStr（char* m） 得到字符串的长度。实现代码如下：
int SizeStr（char* m）
{
int i=0;
while（*（m+i）！=0）
{
i++;
}
return i;
}
④比较两个字符串，如果相等返回true，否则返回false
bool OpD（char* x，char* y）
{
int i=0;
if（SizeStr（x）==SizeStr（y））
{
while（*（x+i）==*（y+i））
{
i++;
if（*（x+i）==0 && *（y+i）==0）
return true;
}
}
return false;
}
⑤通过void LoadItemL1（char **p） 得到所有1元的字串和各自出现的次数
void LoadItemL1（char **p）
{
int i，j，n=0，k=0;
char ch;
char* s;
int f;
memset（cur，0，sizeof（cur））;
for（i=0;i《20;i++）
{
curL1［i］［0］=0;
curL1［i］［1］=0;
}
for（j=0;j《10;j++）
countL1［j］=0;
for（i=0;i《10;i++）
for（j=0;j《4;j++）
{
ch=*（*（p+i）+j）;
if（ch==0）
break;
cur［n］［0］=ch;
n++;
}
curL1［0］［0］=cur［0］［0］;
curL1［0］［1］=cur［0］［1］;
k=0;
for（i=0;i《50;i++）
{
if（cur［i］==0）
break;
s=cur［i］;
f=1;
for（j=0;j《=k;j++）
{
if（OpD（s，curL1［j］））
{
f=0;
break;
}
}
if（f==1）
{
++k;
curL1［k］［0］=cur［i］［0］;
curL1［k］［1］=cur［i］［1］;
}
}
for（i=0;i《20;i++）
for（j=0;j《50;j++）
{
char* m;
m=curL1［i］;
if（*m==0）
break;
if（OpD（m，cur［j］））
countL1［i］++;
}
printf（“L1： \n ”）;
printf（“项集 支持度计数\n”）;
for（i=0;i《10;i++）
{
if（curL1［i］==0）
break;
if（countL1［i］》=2）
printf（“{I%s}： %d\n”，curL1［i］，countL1［i］）;
}
}
⑥通过void SubItem2（char **p） 得到所有的2元子串
void SubItem2（char **p）
{
int i，j，k，n=0;
char* s;
memset（cur，0，sizeof（cur））;
for（i=0;i《20;i++）
{
curL2［i］［0］=0;
curL2［i］［1］=0;
curL2［i］［2］=0;
}
for（i=0;i《10;i++）
countL2［i］=0;
for（k=0;k《10;k++）
{
s=*（p+k）;
if（SizeStr（s）《2）
continue;
for（i=0;i《SizeStr（s）;i++）
for（j=i+1;j《SizeStr（s）;j++）
{
if（*（s+j）==0）
break;
*（cur［n］+0）=*（s+i）;
*（cur［n］+1）=*（s+j）;
*（cur［n］+2）=0;
*（cur［n］+3）=0;
n++;
}
}
}
⑦通过void LoadItemL2（char **p） 得到各个2元频繁子串出现的次数
void LoadItemL2（char **p）
{
int k，i，j;
char* s;
int f;
SubItem2（p）;
curL2［0］［0］=cur［0］［0］;
curL2［0］［1］=cur［0］［1］;
curL2［0］［2］=cur［0］［2］;
k=0;
for（i=0;i《50;i++）
{
if（cur［i］==0）
break;
s=cur［i］;
f=1;
for（j=0;j《=k;j++）
{
if（OpD（s，curL2［j］））
{
f=0;
break;
}
}
if（f==1）
{
++k;
curL2［k］［0］=cur［i］［0］;
curL2［k］［1］=cur［i］［1］;
curL2［k］［2］=cur［i］［2］;
}
}
for（i=0;i《20;i++）
for（j=0;j《50;j++）
{
s=curL2［i］;
if（*s==0）
break;
if（OpD（s，cur［j］））
countL2［i］++;
}
printf（“L2： \n”）;
printf（“项集 支持度计数\n”）;
for（i=0;i《10;i++）
{
if（curL2［i］==0）
break;
if（countL2［i］》=2）
printf（“{I%c，I%c}： %d\n”，curL2［i］［0］，curL2［i］［1］，countL2［i］）;
}
}
⑧通过定义void SubItem3（char **p） 得到所有3元的子串
void SubItem3（char **p）
{
char *s;
int i，j，h，m;
int n=0;
memset（cur，0，sizeof（cur））;
for（j=0;j《20;j++）
{
curL3［j］［0］=0;
curL3［j］［1］=0;
curL3［j］［2］=0;
curL3［j］［3］=0;
}
for（i=0;i《10;i++）
countL3［i］=0;
for（m=0;m《10;m++）
{
s=*（p+m）;
if（SizeStr（s）《3）
continue;
for（i=0;i《SizeStr（s）;i++）
for（j=i+1;j《SizeStr（s）;j++）
{
for（h=j+1;h《SizeStr（s）;h++）
{
if（*（s+h）==0）
break;
*（cur［n］+0）=*（s+i）;
*（cur［n］+1）=*（s+j）;
*（cur［n］+2）=*（s+h）;
*（cur［n］+3）=0;
n++;
}
}
}
}
⑨同样我们要得到得到各个3元频繁子串出现的次数
void LoadItemL3（char** p）
{
int k，i，j;
char* s;
int f;
SubItem3（p）;
curL3［0］［0］=cur［0］［0］;
curL3［0］［1］=cur［0］［1］;
curL3［0］［2］=cur［0］［2］;
curL3［0］［3］=cur［0］［3］;
k=0;
for（i=0;i《50;i++）
{
if（cur［i］==0）
break;
s=cur［i］;
f=1;
for（j=0;j《=k;j++）
{
if（OpD（s，curL3［j］））
{
f=0;
break;
}
}
if（f==1）
{
++k;
curL3［k］［0］=cur［i］［0］;
curL3［k］［1］=cur［i］［1］;
curL3［k］［2］=cur［i］［2］;
curL3［k］［3］=cur［i］［3］;
}
}
for（i=0;i《20;i++）
for（j=0;j《50;j++）
{
s=curL3［i］;
if（*s==0）
break;
if（OpD（s，cur［j］））
countL3［i］++;
}
printf（“L3： \n”）;
printf（“项集 支持度计数\n”）;
for（i=0;i《10;i++）
{
if（curL3［i］==0）
break;
if（countL3［i］》=2）
printf（“{I%c，I%c，I%c}： %d\n”，curL3［i］［0］，curL3［i］［1］，curL3［i］［2］，countL3［i］）;
}
}
⑩定义void LoadItemL4（char** p） 得到各个3元子串出现的次数
void LoadItemL4（char** p）
{
int i;
char* s;
int j=0;
for（i=0;i《10;i++）
{
s=*（p+i）;
if（SizeStr（s）==4）
j++;
}
printf（“四维子集出现的次数： %d\n”，j）;
printf（“没有四维的频繁子集，算法结束！ \n”）;
}
11通过void Support（char* w，int g） 得到关联规则，并输出结果
void Support（char* w，int g）
{
int i，j，k，n=0;
char* s;
float c=0.8，d=0;
memset（cur，0，sizeof（cur））;
s=w;
for（i=0;i《SizeStr（s）;i++）
{
*（cur［n］+0）=*（s+i）;
*（cur［n］+1）=0;
*（cur［n］+2）=0;
*（cur［n］+3）=0;
n++;
}
for（i=0;i《SizeStr（s）;i++）
for（j=i+1;j《SizeStr（s）;j++）
{
if（*（s+j）==0）
break;
*（cur［n］+0）=*（s+i）;
*（cur［n］+1）=*（s+j）;
*（cur［n］+2）=0;
*（cur［n］+3）=0;
n++;
}
for（i=0;i《10;i++）
{
if（SizeStr（cur［i］）==1）
{
for（j=0;j《10;j++）
{
if（OpD（cur［i］，curL1［j］））
{
d=countL3［g］/（float）countL1［j］;
if（d》=c）
printf（“{I%s}： %f”，curL1［i］，d）;
break;
}
}
}
if（SizeStr（cur［i］）==2）
{
for（j=0;j《10;j++）
{
if（OpD（cur［i］，curL2［j］））
{
d=countL3［g］/（float）countL2［j］;
if（d》=c）
printf（“{I%c，I%c}： %f \n”，curL2［j］［0］，curL2［j］［1］，d）;
break;
}
}
}
}
}
12最后通过main函数完成整过程序
int main（int argc， char* argv［］）
{
int i=0，j=0，k;
char buf［10］［6］;
char* p［10］;
char ch;
memset（buf，0，sizeof（buf））;
FILE* fp=fopen（“date.txt”，“r”）;
if（fp==NULL）
return 0;
ch=fgetc（fp）;
while（ch！=EOF）
{
if（ch==0xa || ch==0xd）
{
i++;
ch=fgetc（fp）;
j=0;
continue;
}
buf［i］［j］=ch;
j++;
ch=fgetc（fp）;
}
for（k=0;k《10;k++）
{
*（p+k）=buf［k］;
}
LoadItemL1（p）;
LoadItemL2（p）;
LoadItemL3（p）;
LoadItemL4（p）;
printf（“产生关联规则： \n”）;
printf（“非空子集： 置信度：\n”）;
for（i=0;i《10;i++）
{
if（curL3［i］！=0 && countL3［i］》=2）
Support（curL3［i］，i）;
}
return 0;
}
（4）程序输出结果：
四、学习心得体会
关联算法基本原理学习思路简单，只需一步一步找出频集。再通过支持度算出可信度，如对于A—》C，support=support（{A，C}），confidence= support（{A，C}）/support（{A}）。其中频繁子集的任何子集一定是频繁的，子集频繁父亲一定频繁。相对较难的的部分在于C++代码的实现部分依次实现各个频繁子集，完成整个程序。这学期在商务智能课中学习了数据挖掘的10大算法，数据挖掘十分经典，掌握好一个简单的算法要下很功夫，在今后的工作中一定可以用到，我很庆幸这学期能选到这个课，在这之前听说过数据挖掘但一直没有机会接触，原理容易理解但没接触到以前就没有想过这样考虑问题，学习这个课程以后无论是知识面，智力上都是一个跳跃。还有也提醒我要多复习C++问题的思考，这学期一直忙于网页编程，忘记了上学期说要复习C++数据结构的学习。希望以后还有机会能选到老师的课。
工商网监
评论