mine_assiociation_rules.m

关联规则挖掘算法 Apriori算法的Matlab实现 可以自动生成关联规则

function [xj,candidate]=mine_assiociation_rules(X,th,thconf)
[m,n]=size(X);
%频繁项集通过xj记录
%xj{i}(j).element
%xj{i}(j).time
%其中i表示频繁i项集，j表示频繁i项集中的一个元素，element记录数据项，time记录数据项出现的次数

%寻找频繁1项集
k=0;
for i=1:n
    nm1(i)=sum(X(:,i));
    if nm1(i)>=th
        k=k+1;
        pf1(k)=i; 
        pfxj(k).element=i;
        pfxj(k).time=nm1(i);
    end 
end
xj{1}=pfxj;
clear pfxj;
%生成频繁2项集的候选项
if k>0
    l=0;
    for i=1:k-1
        for j=i+1:k
            l=l+1;
            pf{l}=[pf1(i),pf1(j)];
        end
    end
end
%判断频繁2项集
nm(1:l)=0;  %记录每个候选项出现的次数
for i=1:m
    for j=1:l
        se=pf{j};
        if (X(i,se(1))==1)&(X(i,se(2))==1)
            nm(j)=nm(j)+1;
        end
    end
end
k=0;
%找出频繁2项集
for i=1:l
    if nm(i)>=th
        k=k+1;
        candidate{k}=pf{i};
        pfxj(k).element=pf{i};
        pfxj(k).time=nm(i);
    end
end
xj{2}=pfxj;
clear pfxj;
%连接步，两个集合若满足连接条件，则进行连接，生成K-1项候选集 
num=2;
while( k>0)
    le=length(candidate{1});
    nl=0;
    for i=1:k-1
        for j=i+1:k
            x1=candidate{i};
            x2=candidate{j};
            c = intersect(x1, x2);
            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项自己是否都为频繁的
                r=1; M=0;
                while(r & M<NN)
                    M=M+1;
                    r=in(sub_set{M},candidate);
                end
                if M==NN
                   nl=nl+1;
                   %候选k项集
                   cand{nl}=houxuan;
                end
            end
        end
    end
    %记录每个候选k项集出现的次数
    k=length(cand);
    if k>0
        nn(1:k)=0;
        le=length(cand{1});
        for i=1:m
            for j=1:k
                s=cand{j};
                x=X(i,:);
                if sum(x(s))==le
                    nn(j)=nn(j)+1;
                end
            end
        end       
    end
    %从候选集中找频繁项集
    ll=0;
    candmid=[];
    for i=1:k
        if nn(i)>=th
            ll=ll+1;
            candmid{ll}=cand{i};
            pfxj(ll).element=cand{i};
            pfxj(ll).time=nn(i);
        end
    end
   k=length(candmid);
   if k>0
       num=num+1;
       xj{num}=pfxj;
       clear pfxj;
       candidate=candmid;
   end
    cand=[];  
end
    disp('得到的频繁项集为:')
for i=1:length(candidate)
    result=num2str(candidate{i});
    disp(result)
end
%candidate为最终得到的频繁项集，可以从中得到强规则
disp('得到的强关联规则为:')
%规则生成过程
for j=1:length(candidate)
    hx=candidate{j};
    support=nn/m; %计算支持度，nn记录每个频繁项集的出现次数
    le=length(hx);
    subsetall=ziji(hx);%%生成每个频繁项集的所有非空、非全集子集，利用子集得到规则
    for i=1:le-1
        L=length(subsetall{i});
        for kk=1:L
            %取出一个子集，生成关联规则，并判断置信度
             SS=subsetall{i}{kk};
             mid1=xj{i};
             ln=length(mid1);
             for k=1:ln
                 s=mid1(k).element;
                 if sum(SS==s)==i
                     conf1=mid1(k).time;
                 end
             end
             re=num2str(SS);
             confidence=nn(j)/conf1;%计算置信度
             re2=num2str(setsub(hx,SS));
             result=strcat(re,'=>',re2,'   support  :',num2str(support(j)),'  confidence : ',num2str(confidence));
             if (confidence>=thconf)
                  disp(result) %规则输出
             end
        end
    end
end