叶志伟数据挖掘实验指导书(算法编程部分)

《数据挖掘与数据仓库》实验指导书

2013年

计算机学院计算应用

实验1 Apriori算法实现

一、实验目的

1、掌握Apriori算法对于关联规则挖掘中频繁集的产生以及关联规则集合的产生过程；

2、根据算法描述编程实现算法，调试运行。并结合相关实验数据进行应用，得到分析结果。数据和删除数据的操作。

实验类型：综合

计划课间：2学时

二、实验内容

1、频繁项集的生成与Apriori算法实现；

2、关联规则的生成过程与Rule-generate算法实现；

3、结合样例对算法进行分析；

三、实验步骤

编写程序完成下列算法：

1、Apriori算法

输入：数据集D；最小支持数minsup_count；

输出：频繁项目集L

L1={large 1-itemsets}

For (k=2; Lk-1≠Φ; k++)

Ck=apriori-gen (Lk-1); // Ck是k个元素的候选集

For all transactions t∈D do

begin Ct=subset(Ck,t); //Ct是所有t包含的候选集元素

for all candidates c ∈Ct do c.count++;

end

Lk={c ∈Ck| c.count ≧ minsup_count }

End

L=∪Lk;

2、apriori-gen (Lk-1) 候选集产生算法

输入： (k-1)-频繁项目集Lk-1

输出： k-频繁项目集Ck

For all itemset p∈Lk-1 do

For all itemset q∈Lk-1 do

If p.item1=q.item1, p.item2=q.item2, …,p.itemk-2=q.itemk-2, p.itemk-1

begin c=p∞q

if has_infrequent_subset(c, Lk-1)

then delete c

else add c to Ck

End

Return Ck

3、has_infrequent_subset(c, Lk-1)

功能：判断候选集的元素

输入：一个k-频繁项目集Lk-1 ，(k-1)-频繁项目集Lk-1

输出：c是否从候选集中删除的布尔判断

For all (k-1)-subsets of c do

If Not(S∈Lk-1) THEN return TRUE;

Return FALSE;

4、Rule-generate(L,minconf)

输入：频繁项目集；最小信任度

输出：强关联规则

算法：

FOR each frequent itemset lk in L

generules(lk,lk);

5、Genrules递归算法：

Genrules(lk:frequent k-itemset, xm:frequent m-itemset)

X={(m-1)-itemsets xm-1 | xm-1 in xm};

For each xm-1 in X

BEGIN conf=support(lk)/support(xm-1);

IF (conf≧minconf) THEN

BEGIN

输出规则:xm-1->(lk-xm-1),support,confidence;

IF (m-1)>1) THEN genrules(lk,xm-1);

END;

END;

结合相关样例数据对算法进行调试，并根据相关实验结果对数据进行分析，

四、实验报告要求

1、用C语言或者其他语言实现上述相关算法。

2、实验操作步骤和实验结果，实验中出现的问题和解决方法。

五、注意事项

1、集合的表示及相关操作的实现；

2、项目集的数据结构描述；

参考核心代码如下：（相关的测试main函数可以自己书写。根据频繁k项集生成关联规则相对简单，只需要计算最小置信度即可从频繁K项集中找到所有的满足条件的关联规则。）

//对事物进行第一次扫描，生成频繁一项集，并返回一项集中个数

int init_pass(char *item,char tran[len_t][len],int len,char

res_item[len_t][len],float min_sup)

{

float t_sup;

int number=0;

for(int i=0;i

{

int count=0;

for(int j=0;j

{

for(int k=0;k

if(item[i]==tran[j][k])

{

count++;

break;

}

break;

}

t_sup=count*1.0/len;

if(t_sup>=min_sup)

res_item[number++][0]=item[i];

}

return number-1;

}

//生成候选K项集，返回k项集中事物的个数

int candidate_gen(char ktran[len][k],char kktran[len][k+1]) {

char temp[k],temp1[k],ktemp[k+1];

int number=0;

for(int i=0;i

{

strcpy(temp,ktran[i]);

bool flag;

for(j=i+1;j

{

strcpy(temp1,ktran[i]);

for(int m=0;m

{

if((m

continue;

flag=true;

}

else {

flag=false;

break;

}

}

if(flag)

{

if(temp[k-1]>temp1[k-1])

{

strcpy(ktemp,temp1);

ktemp[k]=temp[k-1];

}

else

{

strcpy(ktemp,temp);

ktemp[k]=temp1[k-1]

}

break;

}

}

flag=judge(kemp,ktran[len][k]);

if(flag==true)

strcpy(kktran[number++],ktemp);

}

return number-1;

}

//判断子集是否在k项集中

bool judge(char *srcstr,char desstr[len][k]) {

char temp[k];

int count=0;

for(int i=0;i

{

for(int j=0;j

temp[j]=srcstr[j];

for(int j=i+1;j

temp[j]=srcstr[j];

for(int p=0;p

if(strcmp(temp,desstr[i])==0)

{

count++;

break;

}

}

if(count==k-1)

return true;

return false;

}

//apriori算法

int apriori(char item[len],char tran[length][len],char res_tran[length][len],float min_sup)

{

char ttran[length][len];

int number,count,t_num;

for(int i=0;i

for(int j=0;j

ttran[i][j]='0';

number=init_pass(item,tran[length][len],len,ttran[length][len],min_sup);

for(int i=0i

res_tran[i][0]=ttran[i][0];

for(int k=2;number!=0;k++)

{

t_num=number;

number=candidate_gen(res_item[number][k-1],ttran[number][k]);

if(k==2)

continue;

else

{

count=0;

for(int i=0;i

{

char temp[k];

strcpy(temp,ttran[i]);

bool t_flag=false;

for(int j=0;j

{//求出候选K项集中每个事物的支持计数

int t_k=0;

for(int n=0;n

bool m_flag=false

for(int g=t_k;g

{

if(temp[k]==tran[j][g])

{

m_flag=true;

t_k=g;

break;

}

}

if(m_flag==true && n==k-1)

t_flag=true;

}

if(t_flag==true)

count++;

flag = false;

}

if(count/length > min_sup)

strcpy(res_item[i],temp);

count=0;

}

}

}

return t_num; }

实验2-1 ID3算法实现

一、实验目的

通过编程实现决策树算法，信息增益的计算、数据子集划分、决策树的构建过程。加深对相关算法的理解过程。

实验类型：综合

计划课间：4学时

二、实验内容

1、分析决策树算法的实现流程；

2、分析信息增益的计算、数据子集划分、决策树的构建过程；

3、根据算法描述编程实现算法，调试运行；

三、实验方法

算法描述：

以代表训练样本的单个结点开始建树；

若样本都在同一个类，则该结点成为树叶，并用该类标记；

否则，算法使用信息增益作为启发信息，选择能够最好地将样本分类的属性；

对测试属性的每个已知值，创建一个分支，并据此划分样本；

算法使用同样的过程，递归形成每个划分上的样本决策树

递归划分步骤，当下列条件之一成立时停止：

给定结点的所有样本属于同一类；

没有剩余属性可以进一步划分样本，在此情况下，采用多数表决进行

四、实验步骤

1、算法实现过程中需要使用的数据结构描述：

Struct

{int Attrib_Col; // 当前节点对应属性

int Value; // 对应边值

Tree_Node* Left_Node; // 子树

Tree_Node* Right_Node // 同层其他节点

Boolean IsLeaf; // 是否叶子节点

int ClassNo; // 对应分类标号

}Tree_Node;

2、整体算法流程

主程序：

InputData();

T=Build_ID3(Data,Record_No, Num_Attrib);

OutputRule(T);

释放内存;

3、相关子函数：

3.1、 InputData()

{

输入属性集大小Num_Attrib;

输入样本数Num_Record;

分配内存Data[Num_Record][Num_Attrib];

输入样本数据Data[Num_Record][Num_Attrib]；

获取类别数C(从最后一列中得到);

}

3.2、Build_ID3(Data,Record_No, Num_Attrib)

{

Int Class_Distribute[C];

If (Record_No==0) { return Null }

N=new tree_node();

计算Data中各类的分布情况存入Class_Distribute Temp_Num_Attrib=0;

For (i=0;i

If (Data[0][i]>=0) Temp_Num_Attrib++;

If Temp_Num_Attrib==0

{

N->ClassNo=最多的类；

N->IsLeaf=TRUE;

N->Left_Node=NULL;N->Right_Node=NULL;

Return N;

}

If Class_Distribute中仅一类的分布大于0

{

N->ClassNo=该类；

N->IsLeaf=TRUE;

N->Left_Node=NULL;N->Right_Node=NULL;

Return N;

}

InforGain=0;CurrentCol=-1;

For i=0;i

{

TempGain=Compute_InforGain(Data,Record_No,I,Num_Attrib); If (InforGain

{ InforGain=TempGain; CurrentCol=I;}

}

N->Attrib_Col=CurrentCol;

//记录CurrentCol所对应的不同值放入DiferentValue[]；

I=0;Value_No=-1;

While i

Flag=false;

For (k=0;k

if (DiferentValu[k]=Data[i][CurrentCol]) flag=true;

if (flag==false)

{Value_No++;DiferentValue[Value_No]=Data[i][CurrentCol] }

I++;

}

SubData=以Data大小申请内存空间；

For (i=0;i

{

k=-1;

for (j=0;j

if (Data[j][CurrentCol]==DiferentValu[i])

{k=k++;

For(int i1=0;i1

If (i1<>CurrentCol)SubData[k][i1]=Data[j][i1];

Else SubData[k][i1]=-1;

}

N->Attrib_Col=CurrentCol;

N->Value=DiferentValu[i];

N->Isleaf=false;

N->ClassNo=0;

N->Left_Node=Build_ID3(SubData,k+1, Num_Attrib);

N->Right_Node=new Tree_Node;

N=N->Right_Node;

}

}

3.3、计算信息增益

Compute_InforGain(Data,Record_No, Col_No, Num_Attrib)

Int DifferentValue[MaxDifferentValue];

Int Total_DifferentValue;

Int s[ClassNo][MaxDifferentValue];

s=0;// 数组清0;

Total_DifferentValue=-1;

For (i=0;i

{

J=GetPosition(DifferentValue,

Total_DifferentValue,Data[i][Col_no]);

If (j<0) {Total_DifferentValue++;

DifferentValue[Total_DifferentValue]=Data[i][Col_no];

J=Total_DifferentValue;}

S[Data[i][Num_Attrib-1]][j]++;

}

Total_I=0;

For (i=0;i

{

Sum=0;

For(j=0;j

}

EA=0;

For (i=0;i

{ temp=0;sj=0; //sj是数据子集中属于类j的样本个数；

For (j=0;j

sj+=s[j][i];

For (j=0;j

EA+=sj/Record_No*Compute_PI(s[j][i]/sj);

}

Return total_I-EA;

}

3.4、得到某数字在数组中的位置

GetPosition(Data, DataSize,Value)

{

For (i=0;i

Return -1;

}

3.5、计算Pi*LogPi

Float Compute_PI(float pi)

{

If pi<=0 then return 0;

If pi>=1 then return 0;

Return 0-pi*log2(pi);

}

五、实验报告要求

1、用C语言或者其他语言实现上述相关算法。

2、实验操作步骤和实验结果，实验中出现的问题和解决方法。

六、注意事项

1、信息增益的计算；

2、选择相关字段后根据相关字段的取值对数据集合进行划分。

3、决策树构建的终止条件

实验2-2 贝叶斯算法实现

一、实验目的

通过对贝叶斯算法的编程实现，加深对贝叶斯算法的理解，同时利用贝叶斯算法对简单应用实现预测分类

实验类型：综合

计划课间：2学时

二、实验内容

1、分析贝叶斯算法；

2、计算条件概率；

3、预测精度的计算与评估；

4、编程实现贝叶斯分类算法，并对简单应用样本数据实现预测分类

5. 参考实验数据https://www.360docs.net/doc/469222334.html,/ml/machine-learning-databases/wine/

三、实验方法

1、实现贝叶斯算法

2、利用实验数据对贝叶斯算法进行检测

3、求解精确度计算

4、调试程序

5、完成整个分类与评估的过程

四、实验步骤

4.1 算法过程描述：

1）输入训练数据，将数据保存在DataBase二维数组中(数组的最后一个属性对应类别标号)

2）设定训练数据集与测试数据集大小(指定从数组下标0开始到TrainSetSize-1所对应的

数据为训练数据，其余为测试数据)；

3）计算训练数据集数据中各属性在各类中的概率分布情况；

4）利用测试数据计算贝叶斯算法的分类精度；

5）输出分类结果；

4.2 数据处理

B、对数据中的枚举类型数据进行转换以便于数据处理：

4.3 计算训练数据集数据中各属性在各类中的概率分布情况如图3-1所示4.4 利用测试数据计算贝叶斯算法的分类精度如图3-2所示

图3-1 训练数据集各属性的概率分布计算

图3-2 贝叶斯算法的分类精度计算

4.5 输出分类结果

For (i=0;i

{printf(“\n”);

For (j=0;j

}

printf(“\n\nTotal Correct is%d”,TotalCorrect);

五、注意事项

注意单个样例数据的概率计算与各字段的概率计算的关系

参考代码 (对参考数据的代码)

BayesianClassifier.h

#include

#include

#include

#include

#include

#include

#include

using namespace std;

// 1) Alcohol

// 2) Malic acid

// 3) Ash

// 4) Alcalinity of ash

// 5) Magnesium

// 6) Total phenols

// 7) Flavanoids

// 8) Nonflavanoid phenols

// 9) Proanthocyanins

// 10)Color intensity

// 11)Hue

// 12)OD280/OD315 of diluted wines

// 13)Proline

int TrainNum = 130; //所有训练数据的范围

int TestNum = 48;

struct OriginalData

{

double A1;

double A2;

double A3;

double A4;

double A5;

double A6;

double A7;

double A8;

double A9;

double A10;

double A11;

double A12;

double A13;

double A14;

};

BayesianClassifier.cpp

#include

#include

#include

#include"BayesianClassifier.h"

using namespace std;

const int Shuxing=13;//属性总数

ifstream f;

vector trainData; //存放训练数据

vector testData; //存放测试数据

double A[3]; //先验概率

int m;

//存放每一类型，每种属性中某数值的概率

map C1_map[Shuxing];

map C2_map[Shuxing];

map C3_map[Shuxing];

//从文件中读取数值

void DataRead(vector &data, const char* fileName)

{

f.open(fileName);

int ZHjiang;

if (fileName[0] == 'w')

ZHjiang = TrainNum;

else

ZHjiang = TestNum;

string line;

OriginalData wine;

for (int i = 0; i < ZHjiang; i++)

{

f >> line;

while (line.find(',') > 0 && line.find(',') < line.length())

{

line[line.find(',')] = ' ';

}

istringstream stream(line);

stream >> wine.A1 >> wine.A2 >> wine.A3 >> wine.A4 >> wine.A5 >> wine.A6 >> wine.A7 >> wine.A8 >>

wine.A9 >> wine.A10 >> wine.A11 >> wine.A12 >> wine.A13 >> wine.A14;

data.push_back(wine);

}

f.close();

}

void bayes()

{

int count1 = 0, count2 = 0, count3 = 0;

int i;

for(i = 0; i < TrainNum; i++)

{

if(trainData[i].A1 == 1)

{

count1 ++;

}

if(trainData[i].A1 == 2)

{

count2 ++;

}

if(trainData[i].A1 == 3)

{

count3 ++;

}//统计三类数据,各自求和

}

A[0] = (double)count1/(double)TrainNum; //求先验概率

A[1] = (double)count2/(double)TrainNum;

A[2] = (double)count3/(double)TrainNum;

map::iterator pipei;

for(i = 0 ; i < TrainNum; i++)

{

if(trainData[i].A1 == 1) //求P(Xk|C1) 中Xk的个数

{

int j=0;

for(;j< 13 ;j++)

{

double temp = *(&trainData[i].A2+j);

pipei = C1_map[j].find(temp);

if(pipei == C1_map[j].end())

{

C1_map[j].insert(map::value_type(temp,1));

}

else

{

double j = pipei->second;

pipei->second = j + 1;

}

}

}

if(trainData[i].A1 == 2) //求P(Xk|C2) 中Xk的个数

{

int j = 0;

for(;j< 13 ;j++)

{

double temp = *(&trainData[i].A2+j);

pipei = C2_map[j].find(temp);

if(pipei == C2_map[j].end())

{

C2_map[j].insert(map::value_type(temp,1));

}

else

{

double j = pipei->second;

pipei->second = j + 1;

}

}

}

if(trainData[i].A1 == 3) //求P(Xk|C3) 中Xk的个数

{

int j = 0;

for(;j< 13 ;j++)

{

double temp = *(&trainData[i].A2+j);

pipei = C3_map[j].find(temp);

if(pipei == C3_map[j].end())

{

C3_map[j].insert(map::value_type(temp,1));