数据挖掘-Apriori算法

最新推荐文章于 2023-06-14 02:00:34 发布
最新推荐文章于 2023-06-14 02:00:34 发布
阅读量1.2k 收藏
点赞数
文章标签： 数据挖掘 c apriori

算法  Apriori

Input:          Transaction DataBase D，Minimum support threshold minsup。

Output：      Frequent pattern L

(1) L1=search_frequent_1-itemsets( D );

(2) for(k=2;Lk-1≠φ;k++) do

(3) begin

(4)    Ck=apriori-gen(Lk-1);

(5)    for all transactions t D do

(6)    begin

(7)      Ct=subset(Ck，t);

(8)      for all candidates c Ct do

(9)        c.count++;

(10)    end

(11)    Lk ={c Ck|c.count≥minsup}

(12) end

(13) Answer L=∪kLk;

Procedure Search_frequent_1-itemsets( D )

(1) begin

(2)  for all transactions t D do

(3)  begin

(4)    for each item ik t do

(5)      ik.count++;

(6)  end

(7)  L1 ={ i I | i.count≥minsup}

(8)  return L1;

(9) end

Procedure apriori_gen(Lk)

(1) begin

(2)   for each itemset l1 Lk do

(3)     for each itemset l2 Lk do

(4)     begin

(5)       if ( l1[1]=l2[1]) ( l1[2]=l2[2]) … ( l1[k-1]=l2[k-1]) ( l1[k]<l2[k]) then

(6)       begin

(7)          c= l1 l2;

(8)          if Is_include_infrenquent_subset(c,Lk) then

(9)             delete c;

(10)         else add c to Ck+1 ;

(11)       end

(12)      end

(13)    return Ck+1 ;

(14) end

Procedure Is_include_infrenquent_subset(c,Lk)

(1)begin

(2)  for each k-subset s of c

(3)     if s Lk then

(4)       reture TURE;

(5)  return FALSE ;

(6)end

在主程序中，第一步首先扫描整个交易数据库D，统计每个项目(item)的支持数，计算其支持度，将支持度大于等于最小支持度minsup的项目构成的集合放入到L1 中；从第2步到第11步，用k-1频繁项目集构成的Lk-1生成候选集的集合Ck，以便从中生成Lk，其中apriori_gen函数(第4步)用来从Lk-1中生成Ck，然后对数据库进行扫描(第5步)，对于数据库中的每一个交易，subset函数用来发现此交易包含的所有候选集(第7步)，并为这些候选集的计数器加1(第8-9步)。最后满足minsup的候选集被放入到Lk中。

apriori_gen过程完成两种操作：并(join)和剪枝(prune)。在并运算步骤中，Lk-1 与Lk-1 进行并运算生成潜在的候选集(2-7步)，条件l1[k-1]<l2[k-1]保证不会有重复的候选集生成(第5步)。在剪枝步骤中(8-10步)，利用性质2.1，删除那些存在子集不是频繁项目集的候选集，测试子集是否为频繁项目集由过程Is_include_infrenquent_subset完成。

为了清楚的阐述Apriori算法的挖掘过程，现举例如下：

【例1】设事务数据库D如表2.1所示，D中包含4个事务，即|D|=4，最小支持数mincount=2，即最小支持度minsup=2/4=50%。挖掘频繁项目集的具体过程如下所述：C1={{A},{B},{C},{D},{F}}，第一次循环产生L1={{A},{B},{C},{F}}，由Apriori_gen(L1)生成C2，扫描数据库，计算C2中每个候选集得到L2。依此循环，得到L3。整个挖掘过程如图2.1所示。

表1 事务数据库D

Tid

事务

100

200

300

400

B,C,F

A,C,D

B,F

A,B,C,F

   

 

图1 Apriori算法的执行过程

在找到了事务数据库中的所有频繁项集后，利用这些频繁项集可以产生关联规则，产生关联规则的步骤如下：

(1) 对于每个频繁项目集l，产生l的所有非空子集。

(2) 对于l的每个非空子集m，如果support(l)/support(m)≥minconf，则输出规则“m (l-m)”。

例如，在上例中产生的频繁项目集l＝{B,C,F}，l的非空子集有{B,C}、{B,F}、{C,F}、{B}、{C}和{F}，则运用上述产生关联规则的方法可以得到以下关联规则：

          B C F    confidence=(2/4)/(4/4)=1

          B F C    confidence=(2/4)/(3/4)=0.667

          C F B    confidence=(2/4)/(2/4)=1

          F B C    confidence=(2/4)/(3/4)= 0.667

          C B F    confidence=(2/4)/(3/4)= 0.667

          B C F    confidence=(2/4)/(3/4)= 0.667

 

 

 

源代码  apriori.c

//

#include<stdio.h>
typedef  struct 
{
int item[100];  //数据项
} D_Node;      //数据库D


typedef  struct 
{
int item[100];  //数据项,用item[0]保存支持度

} C_Node; //候选集

typedef  struct 
{
int item[100];  //数据项,用item[0]保存支持度
} L_Node;//频繁集

C_Node C[100][100];
L_Node L[100][100];
D_Node D[100];

int min_supp;  //最小支持度

 

void  InPut()
{
 int i,j,n,n1;
 printf("请输入最小支持度:");
 scanf("%d",&min_supp);
  printf("请输入交易集的大小");
  scanf("%d",&D[0].item[0]);
  n=D[0].item[0];

     for(i=1;i<=n;i++)  //for1
     {   
        printf("请输入交易[%d]中记录的个数(n)",i);
         scanf("%d",&n1);
         D[i].item[0]=n1;

           for(j=1;j<=n1;j++)  //for2
           {
              printf("请输入交易[%d]中记录项，直接输入数字:",i);
              scanf("%d",&D[i].item[j]);                  
           }//for2
                 
           }  //for1
     
     }//end of InPut


void  C1()
{
 //功能：扫描数据集D生成1项候选集C1
 //输入：数据集D
 //输出1项候选集C1
 //初始条件 数据集D 非空
   int i,j,k;
   int no=1,temp=0;
   C[1][0].item[0]=0;  //1 项集的个数，在本算法中，用C[n][k].item[0]来保存候选集Cn的第k项的支持度
   if(D[0].item[0]!=0)
   {  
      C[1][1].item[1]=D[1].item[1];
          
   }
      
    for(i=1;i<=D[0].item[0];i++)  //for1  
    { 
  
         for(j=1;j<=D[i].item[0];j++)  //for2   
      {
               temp=1;
               for(k=1;k<=no;k++)  //for3
      { 
                  if(C[1][k].item[1]==D[i].item[j])
            {
                     C[1][k].item[0]++;  //支持度加1
                      temp=0;  //
                           
                  }   //if

               }//end for3
            
          
              if(temp)//生成新的项集
           { 
                    C[1][++no].item[1]=D[i].item[j];
                    C[1][no].item[0]=1;     
           } 
       
         }//end for2
   
    } // end  for1

    C[1][0].item[0]=no;//数据项的个数 

}  //end of  C1()


void Cn( int n)
{  
 //用频繁集Ln-1为基础，通过连接得到n项候选集Cn
 
 int i,j,k,p,q,s,t,num;
 int no=0,temp=0,count;

 C[n][0].item[0]=0;  //初始化

//printf("in Cn(%d) n=%d/n",n,n);
//printf("in Cn(%d) C[%d][0].item[0]=%d/n",n,n,C[n][0].item[0]);

num=L[n-1][0].item[0];  //num是Ln-1项集的数据个数

   for(i=1;i<=num;i++)  
  
      for(j=i+1;j<=num;j++)   //for2
         {
   
      temp=1;  //测试是否满足联结条件
              if(n>2)//if 1
              {
                  for(k=1;k<n-1;k++)     //for3   
                 {
      if(L[n-1][i].item[k]!=L[n-1][j].item[k])
                   {  temp=0;
                     break; }//if 1

                    }//end for3

                 }//end if1

                      if(temp==1)//满足联结条件
                     {
                          // printf("in if 2  no=%d/n",no);
                     no++;

                    for(p=1;p<=n-1;p++)  
                    C[n][no].item[p]=L[n-1][i].item[p];
                    C[n][no].item[p]=L[n-1][j].item[p-1];
                    C[n][no].item[0]=0;
                         for(q=1;q<=D[0].item[0];q++)  //for5  测试其支持度

       {    
        
        count=0; //count用来记数,当所测试的项存在时,count加1,当count=n时，则子集存在

                               for(s=1;C[n][no].item[s]!=0;s++)  //for6
                          {
                                      for(t=1;t<=D[q].item[0];t++)  //for7
           {
                                             if(C[n][no].item[s]==D[q].item[t])

            {   count+=1;
                      break;
            } 
           }//end for7
                                     
          }//end for 6
                           if(count==n) C[n][no].item[0]+=1;//子集存在,第no项的支持度加1
                   
       }//end for5
                           
                           
                      C[n][0].item[0]+=1;
       }//end if2
           }//end for2

    
   
}//end of Cn()

void L1()
{   
    int i,j,k;
 j=0;
   L[1][0].item[0]=0;
   
   //printf("C[1][0].item[0]=%d/n",C[1][0].item[0]);

   for(i=1;i<=C[1][0].item[0];i++)
   {    
       if(C[1][i].item[0]>=min_supp)
       {
       j+=1;
        for(k=1;k<=1;k++)
         L[1][j].item[k]=C[1][i].item[k];
        L[1][j].item[0]=C[1][i].item[0];
 // printf("L[1][%d].item[1]=%d   ",j,L[1][j].item[1]);  测试功能时加的
 // printf("  -------------%d/n",L[1][j].item[0]);
  
       }
   }//end for1
   L[1][0].item[0]=j;
}//end of L1()

void Ln(int n)
{   
    int i,j,k;
 Cn(n);
    j=0;
    L[n][0].item[0]=0;

   // printf("in Ln(%d) C[%d][0].item[0]=%d/n",n,n,C[n][0].item[0]);

   for(i=1;i<=C[n][0].item[0];i++)  //for 1
   {
       if(C[n][i].item[0]>=min_supp)
       {
         j+=1;
        for(k=1;k<=n;k++)
         L[n][j].item[k]=C[n][i].item[k];
        L[n][j].item[0]=C[n][i].item[0]; 
       }  //end if


   }//end for1

  

L[n][0].item[0]=j; //保存数据的个数

}//end of Ln(int n)


  void  OutPut(int n)
  {
     int i,j,k;
     printf("频繁项目集L%d如下:/n",n);
     k=L[n][0].item[0];
         if(k!=0)
         { 
             for(i=1;i<=k;i++)
          {
                printf("{");
               for(j=1;j<=n;j++)      
        printf("  I%d ",L[n][i].item[j]);
        printf("}        支持度:%d/n",L[n][i].item[0]);
           
      
             }//for
            
          }
         else                printf("项目集为空/n");
           
      
  }


  void main()
  {
 int i;
 int n=1;
    InPut();
 C1();//初始化,生成1项候选集C1
 L1();//得到1项频繁集L1
    while(L[n][0].item[0]!=0)
 {
  n+=1;
        Ln(n);
 }
    for(i=1;i<=n;i++)
        OutPut(i);

 char ch;
   scanf("%d",&i);
  
  }

 

 

--------------------------------------------------------------------------------------

FAST apriori.cpp

//

#include <stdio.h>
#include <string.h>

typedef  struct 
{
char item[10];  //数据项
int min_supp_count;//最小支持度数
} C_Node;      //候选集


typedef  struct 
{
char item[10];  //数据项
int min_supp_count;//最小支持度数
} L_Node;     //频繁集

char D[10][10];
L_Node L[100];
C_Node C[100];
int min_supp_count=2;
int num=100;
void  InPut()
{

 strcpy(D[1],"abe");
 strcpy(D[2],"bd");
 strcpy(D[3],"bc");
 strcpy(D[4],"abd");
 strcpy(D[5],"ac");
 strcpy(D[6],"bc");
 strcpy(D[7],"ac");
 strcpy(D[8],"abce");
 strcpy(D[9],"abc");

 
}//end of InPut
int  * DB=new int[num];

 

void suppDB()
{
  int m='e';
  int n;
  int k;
  for (int i=1;i<=9;i++)
  {
   n=strlen(D[i]);
   DB [i]=0;
   for (int j=0;j<n;j++)
   {
    k=1; 
    DB [i]+=k<<(int)(m-D[i][j]);  
   }  
  }

 

}

void check_supp(int num,int no)
{
int i,j,k,m;
    int check;
   m='e';
   
     for(i=1;i<=num;i++)
  {    check=0;
       C[i].min_supp_count=0;
       for (j=0;j<no;j++)
    {
   k=1;
   check+=(int)(k<<(m-C[i].item[j]));
      }
   for (j=1;j<=9;j++)
   {
    if (check==(check&DB[j]))
    {
      C[i].min_supp_count+=1;//子集存在，支持度数加1
    }
   }
  }

}

void  C1()
{
 //功能：扫描数据集D生成1项候选集C1
 //输入：数据集D
 //输出1项候选集C1
 //初始条件 数据集D 非空
 strcpy(C[1].item,"a");
 strcpy(C[2].item,"b");
 strcpy(C[3].item,"c");
 strcpy(C[4].item,"d");
 strcpy(C[5].item,"e");
   
   C[0].min_supp_count=5;  //1 项候选集的个数，在本算法中，用C[0].min_supp_count来保存候选集Cn的个数  

  check_supp(5,1);
  
   
 }  //end of  C1()


void Cn( int n)
{  
 //用频繁集Ln-1为基础，通过连接得到n项候选集Cn
 
 int i,j,k,p,num;
 int no=0,temp=0;

 C[0].min_supp_count=0;  //初始化


num=L[0].min_supp_count;  //num是Ln-1项集的数据个数

   for(i=1;i<=num;i++)  
  
      for(j=i+1;j<=num;j++)   //for2
         {
   
      temp=1;  //测试是否满足联结条件
              if(n>2)//if 1
              {
                  for(k=0;k<n-2;k++)     //for3   
                 {
      if(L[i].item[k]!=L[j].item[k])
                   {  temp=0;
                     break; }//if 1

                    }//end for3

                 }//end if1

                      if(temp==1)//满足联结条件
                     {
                          // printf("in if 2  no=%d/n",no);
                     no++;

                    for(p=0;p<=n-2;p++)  
                    C[no].item[p]=L[i].item[p];
                    C[no].item[p]=L[j].item[p-1];
                    C[no].min_supp_count=0;
                    C[0].min_supp_count+=1;
       }//end if2
           }//end for2
num=C[0].min_supp_count;
   check_supp(num,n);//测试支持度 
}//end of Cn() 


void L1()
{   int n=1;
    int i,j,k;
 j=0;
   L[0].min_supp_count=0;//频繁集的个数，初始为0
    
   for(i=1;i<=C[0].min_supp_count;i++)
   {    
       if(C[i].min_supp_count>=min_supp_count)
       {
       j+=1;
        strcpy(L[j].item,C[i].item);  
  L[j].min_supp_count=C[i].min_supp_count;
       }
   }//end for1
   L[0].min_supp_count=j;///频繁集的个数,最后为j个

    printf("频繁项目集L%d如下:/n",n);
     k=L[0].min_supp_count;
         if(k!=0)
         { 
             for(i=1;i<=k;i++)
          {
                printf("{");
               for(j=0;j<n;j++)      
        printf("  %c ",L[i].item[j]);
        printf("}        支持度:%d/n",L[i].min_supp_count);
           
      
             }//for
            
          }
         else                printf("项目集为空/n");

}//end of L1()

void Ln(int n)
{   
    int i,j,k;
 Cn(n);
    j=0;
    L[0].min_supp_count=0;

   
   for(i=1;i<=C[0].min_supp_count;i++)  //for 1
   {
       if(C[i].min_supp_count >=min_supp_count)
       {
         j+=1;
        strcpy(L[j].item,C[i].item);  
  L[j].min_supp_count=C[i].min_supp_count;
         
       }  //end if


   }//end for1

  

L[0].min_supp_count=j; //保存数据的个数
 printf("频繁项目集L%d如下:/n",n);
     k=L[0].min_supp_count;
         if(k!=0)
         { 
             for(i=1;i<=k;i++)
          {
                printf("{");
               for(j=0;j<n;j++)      
        printf("  %c ",L[i].item[j]);
        printf("}        支持度:%d/n",L[i].min_supp_count);
           
      
             }//for
            
          }
         else                printf("项目集为空/n");

}//end of Ln(int n)


 void main()
{

   
      int n=1;
    InPut();
 suppDB();
 C1();//初始化,生成1项候选集C1
 L1();//得到1项频繁集L1
  while(L[0].min_supp_count!=0)
 {
  n+=1;
        Ln(n);
  }
  char ch;
  printf("press any key to eixe/n");
  scanf("%c",&ch);
   
   }

青天揽月
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据挖掘课程设计-Apriori算法实现
12-27
这是对于数据挖掘课程的一个小结，花了大约三天的时间完成，总的来说完成的还可以，虽然实现的效果不咋地。
A-Priori算法及其优化（FP树）
qq_45060674的博客
05-26 4146
在本文中，我们将通过示例先了解A-Priori算法，其基本思路是：若一个集合的子集不是频繁项集，那么该集合也不可能是频繁项集。基于此，该算法可以通过检查小集合而去掉大部分不合格的大集合。 接着，我们介绍基本的A-Priori算法的改进——FP树，并通过手绘过程的方式来协助理解。
Apriori算法挖掘频繁项集
喔吼吼吼
01-22 2120
用Apriori或者FP-growth算法挖掘出所有的频繁项集，并写出具体的实现代码。假设事务数据库D表1：最小支持度计数为2. 下图是以Apriori算法为例。 表1事务数据库D Tid Items 10 A,C,D 20 B,C,E 30 A,B,C,E 40 B,E 一、...
第三次作业
u013864857的专栏
03-04 368
实验三 Apriori算法的频繁项集产生
weixin_62439904的博客
06-14 491
上图可以看出置信度为0.37左右，说明({'Class Values: unacc'})和({'lug_boot: small'})之间的相关性不高，后备箱的大小和人们的满意度没有太大的关系。通过这个图可以看见置信度为1，为最大值，说明({'safety: low'})和({'Class Values: unacc'})的数据关联性很高，因为安全度不高，同时人们的满意度也不高。通过图六，图七，图八，可以看到，提高最小支持度，和提高最小置信度，频繁项集的数目会减少，甚至不出现频繁3项集。
Apriori算法求频繁项目集的java实现
叶桐的博客
12-12 897
package dmm2; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Set; public class dmm { int zcd=2; //zhichidu double kxd=0.7; //kexingdu String fg=","; //fengefu String jg="-"; //jie
数据挖掘作业5（个数据库有5个事务，如下表所示。设min_sup=60%,min_conf=80%）
热门推荐
阿火
05-03 4万+
5.7一个数据库有5个事务，如下表所示。设min_sup=60%,min_conf=80%。 （1）分别用Apriori算法和FP-growth算法找出所有频繁项集，比较两种挖掘方法的效率。 （2）比较穷举法和Apriori算法生成的候选项集的数量。 （3）利用（1）所找出的频繁项集，生成所有的强关联规则和对应的支持度和置信度。 ![在这
【数据挖掘复习题】
AXDLMG7的CSDN~
06-12 1万+
1.下面哪个不属于数据的属性类型 A.标称 B.序数 C.区间 D.相异2.属于定量的属性类型是 A.标称 B.序数 C.区间 D.相异3.一所大学内的各年纪人数分别为：一年级200人，二年级160人，三年级130人，四年级110人。则年级属性的众数是 A.一年级 B.二年级 C.三年级 D.四年级4.假设属性income的最大最小值分别是12000元和98000元。利用最大最小规范化的方法将属性的值映射到0至1的范围内。对属性income的73600元将被转化为 A.0.821 B.1.224 C.1.4
数据挖掘-关联分析与Apriori算法详解
最新发布
04-03
数据挖掘|关联分析与Apriori算法详解
数据挖掘apriori算法-java语言源码AR.zip
02-27
Apriori算法是关联规则挖掘的代表性算法，十大数据挖掘算法之一，可见其重要性。它的主要作用是发现事物之间的内在联系。 Apriori算法的基本思想是通过对数据的多次扫描来计算项集的支持度，发现所有的频繁项集从而...
Appriori算法
06-22
本资源由@Joe Chael提供，数据库有5个事务。设min_sup=60%,min_conf=80%。（1）使用Apriori算法找出所有频繁项集。（2）列举两条强关联规则。详情参见：http://blog.csdn.net/qingdujun/article/details/46586721
关联规则数据挖掘Apriori算法的JAVA实现
01-22
JAVA实现的关联规则的数据挖掘Apriori算法，采用图形化界面形式，可以实现从布尔类型数据库中找出关联规则
apriori算法找频繁项集，和强关联规则
Mr.wu`的博客
10-08 1万+
apriori算法找频繁项集，和强关联规则 一、找频繁项集 假设数据集如下 TID transactions 1 {1,3,4} 2 {2,3,5} 3 {1,2,3,5} 4 {2,5} 假设可信度：70%，支持度：50% 求频繁1项集 {1,2,3,4,5}的1项集：{1}、{2}、{3}、{4}、{5}。比如{1}在数据集TID1、3中都有出现，则出现的次数为2，依次类推2,3,4,5.我们可以得到以下表格 l1(数据元) C1（出现的次数） 1 2
数据仓库与数据挖掘课后思考题整理
欢迎自九陌而来的你做客九陌斋！
07-14 3917
数据仓库与数据挖掘课后思考题整理 文章目录数据仓库与数据挖掘课后思考题整理1 数据仓库概述思考题2 数据仓库及其设计思考题实践题3 OLAP技术思考题课后书面作业4 数据挖掘概述思考题5 关联分析思考题实践题7 分类方法思考题实践题8 回归和时序分析思考题实践10 聚类方法思考题 1 数据仓库概述 思考题 简述数据仓库有哪些主要的特征。 ① 面向主题 ② 集成 ③ 稳定性即非易失的 ④ 随时间变化而随时变化的 面向主题 主题是指用户使用数据仓库进行决策时所关心的重点领域，也就是在一个较高的
关联规则挖掘 Apriori算法
weixin_44018134的博客
01-08 1801
数据要求 执行部分里修改文件路径， csv文件输入，第一列为事务列，第二列及以后为项集列 参数调节 可调参数：执行部分里的k=2, min_support=0.01，min_conf=0.15可调节，并有说明 import time import csv def readData(fileName):#数据导入 """ read the csv data into a dictio...
数据挖掘算法之 Apriori
Xcy的博客
10-21 1351
一、什么是Apriori算法？         Apriori算法是寻找所有支持度不小于minsup的项集。项集的支持度指的是包含该项集的事务占所有事务的比例。频繁项集指的是满足给定最下支持度的项集         Apriori算法是由Agrawal等人于1993提出的，它采用逐层搜索策略（层次搜索策略）产生所有的频繁项集。          Apriori性质：
数据挖掘考题汇总（填空题与计算题）带答案
闭关修炼——暂退
05-02 3万+
目录 一、填空题 二、计算题 一、填空题 ❃随着信息技术的高速发展，数据库应用的规模、范围和深度不断扩大，网络环境成为主流等等。产生“数据丰富而信息贫乏”现象。 ❃“数据丰富而信息贫乏”现象导致大数据概念。 ❃数据（Data）、信息（Information）和知识（Knowledge）是广义数据表现的不同形式。 ❃大数据时代的数据挖掘技术需求分析的流派：数据论、方法论、环境论、特征论...
关联规则算法Apriori的学习与实现
weixin_30764883的博客
04-24 282
转自关联规则算法Apriori的学习与实现 首先我们来看，什么是规则？规则形如”如果…那么…(If…Then…)”,前者为条件，后者为结果。关联规则挖掘用于寻找给定数据集中项之间的有趣的关联或相关关系。关联规则揭示了数据项间的未知的依赖关系，根据所挖掘的关联关系，可以从一个数据对象的信息来推断另一个数据对象的信息。例如购物篮分析。牛奶 ⇒面包 [支持度：3%，置信度：40%...
频繁项集挖掘算法——Apriori算法
my_learning_road的博客
03-28 2万+
前言        关联规则就是在给定训练项集上频繁出现的项集与项集之间的一种紧密的联系。其中“频繁”是由人为设定的一个阈值即支持度 （support）来衡量，“紧密”也是由人为设定的一个关联阈值即置信度（confidence）来衡量的。这两种度量标准是频繁项集挖掘中两个至关重 要的因素，也是挖掘算法的关键所在。对项集支持度和规则置信度的计算是影响挖掘算法效率的决定性因素，也是对频繁项集挖掘进行改...
数据挖掘之apriori算法
05-17
Apriori算法是一种常见的关联规则挖掘算法，用于发现数据集中项集之间的关联关系。Apriori算法基于频繁项集的概念，即在数据集中经常出现的项集。该算法首先生成所有可能的项集，然后通过剪枝来移除不频繁的项集，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值