关联规则挖掘算法

Apriori算法实现
最新推荐文章于 2018-10-22 13:41:44 发布
最新推荐文章于 2018-10-22 13:41:44 发布
阅读量68 收藏
点赞数
CC 4.0 BY-SA版权
原文链接：http://www.cnblogs.com/yechanglv/p/6923402.html
using  System;
using  System.Collections.Generic;
using  System.ComponentModel;
using  System.Data;
using  System.Drawing;
using  System.Text;
using  System.Windows.Forms;
using  System.Collections;
namespace  Apriori
{
     //事务
     struct  trans
     {
         public  string  tID;
         public  ArrayList items;
     }
     //项集和支持度计数
     struct  itemAndSup
     {
         public  ArrayList items;
         public  int  sup;
     }
     public  partial  class  Form1 : Form
     {
         private  ArrayList tData =  new  ArrayList();       //事务数据
         private  int  minSup = 2;                          //最小支持度计数阀值
         private  ArrayList C0 =  new  ArrayList();          //L的超集
         private  ArrayList L0 =  new  ArrayList();          //频繁k项集
         private  int  step;                                //已完成步骤数
         private  bool  finish;                             //算法是否完成
         public  Form1()
         {
             InitializeComponent();
         }
         private  void  Form1_Load( object  sender, EventArgs e)
         {
             Init();
         }
         //初始化程序主界面
         private  void  Init()
         {
             this .Text =  "关联规则算法" ;
             tData.Clear();
             C0.Clear();
             L0.Clear();
             this .TDataView.Items.Clear();
             this .CResultView.Items.Clear();
             this .LResultView.Items.Clear();
             this .ItemList.Items.Clear();
             this .TDataView.Items.Add( "TID\t商品ID的列表\n" );
             this .ItemList.Items.Add( "I1" );
             this .ItemList.Items.Add( "I2" );
             this .ItemList.Items.Add( "I3" );
             this .ItemList.Items.Add( "I4" );
             this .ItemList.Items.Add( "I5" );
             this .confList.Items.Add( "I1" );
             this .confList.Items.Add( "I2" );
             this .confList.Items.Add( "I3" );
             this .confList.Items.Add( "I4" );
             this .confList.Items.Add( "I5" );
             this .ListConf.Items.Add( "I1" );
             this .ListConf.Items.Add( "I2" );
             this .ListConf.Items.Add( "I3" );
             this .ListConf.Items.Add( "I4" );
             this .ListConf.Items.Add( "I5" );
             this .txtbMinSup.Text = minSup.ToString();
             step = 0;
             finish =  false ;
         }     
         
         //删除事务
         private  void  DeleteItem_Click( object  sender, EventArgs e)
         {
             if  ( this .TDataView.SelectedIndex == 0)
                 return ;
             tData.RemoveAt( this .TDataView.SelectedIndex - 1);
             this .TDataView.Items.RemoveAt( this .TDataView.SelectedIndex);
         }
         //示例事务
         #region
         private  void  Example_Click( object  sender, EventArgs e)
         {
             example();
         }
         private  void  example()
         {
             trans t1 =  new  trans();
             t1.tID =  "T100" ;
             t1.items =  new  ArrayList();
             t1.items.Add( "I1" );
             t1.items.Add( "I2" );
             t1.items.Add( "I5" );
             AddItemToDataView(t1);
             tData.Add(t1);
             trans t2 =  new  trans();
             t2.tID =  "T200" ;
             t2.items =  new  ArrayList();
             t2.items.Add( "I2" );
             t2.items.Add( "I4" );
             AddItemToDataView(t2);
             tData.Add(t2);
             trans t3 =  new  trans();
             t3.tID =  "T300" ;
             t3.items =  new  ArrayList();
             t3.items.Add( "I2" );
             t3.items.Add( "I3" );
             AddItemToDataView(t3);
             tData.Add(t3);
             trans t4 =  new  trans();
             t4.tID =  "T400" ;
             t4.items =  new  ArrayList();
             t4.items.Add( "I1" );
             t4.items.Add( "I2" );
             t4.items.Add( "I4" );
             AddItemToDataView(t4);
             tData.Add(t4);
             trans t5 =  new  trans();
             t5.tID =  "T500" ;
             t5.items =  new  ArrayList();
             t5.items.Add( "I1" );
             t5.items.Add( "I3" );
             AddItemToDataView(t5);
             tData.Add(t5);
             trans t6 =  new  trans();
             t6.tID =  "T600" ;
             t6.items =  new  ArrayList();
             t6.items.Add( "I2" );
             t6.items.Add( "I3" );
             AddItemToDataView(t6);
             tData.Add(t6);
             trans t7 =  new  trans();
             t7.tID =  "T700" ;
             t7.items =  new  ArrayList();
             t7.items.Add( "I1" );
             t7.items.Add( "I3" );
             AddItemToDataView(t7);
             tData.Add(t7);
             trans t8 =  new  trans();
             t8.tID =  "T800" ;
             t8.items =  new  ArrayList();
             t8.items.Add( "I1" );
             t8.items.Add( "I2" );
             t8.items.Add( "I3" );
             t8.items.Add( "I5" );
             AddItemToDataView(t8);
             tData.Add(t8);
             trans t9 =  new  trans();
             t9.tID =  "T900" ;
             t9.items =  new  ArrayList();
             t9.items.Add( "I1" );
             t9.items.Add( "I2" );
             t9.items.Add( "I3" );
             AddItemToDataView(t9);
             tData.Add(t9);
         }
         #endregion
         //最小支持度阈值变化
         private  void  txtbMinSup_TextChanged( object  sender, EventArgs e)
         {
             try
             {
                 //获得最小支持度阈值，将其赋给minSup
                 minSup =  int .Parse( this .txtbMinSup.Text);
             }
             catch
             {
                 MessageBox.Show( "非法输入！" );
                 this .txtbMinSup.Text = minSup.ToString();
             }
         }
         //添加事务
         #region
         //获得事务ID号
         public  string  GetTID()
         {
             return  this .TID.Text;
         }
         //获得事务中的项
         public  ArrayList GetItemList()
         {
             ArrayList items =  new  ArrayList();
             for  ( int  i = 0; i <  this .SelectItemList.Items.Count; i++)
             {
                 string  itemID =  this .SelectItemList.Items[i].ToString();
                 items.Add(itemID);
             }
             items.Sort();
             return  items;
         }
         //添加项到备选栏
         private  void  Add_Click( object  sender, EventArgs e)
         {
             if  ( this .ItemList.SelectedIndex < 0)
                 return ;
             for  ( int  i = 0; i <  this .SelectItemList.Items.Count; i++)
             {
                 if  ( this .SelectItemList.Items[i] ==  this .ItemList.SelectedItem)
                     return ;
             }
             this .SelectItemList.Items.Add( this .ItemList.SelectedItem);
         }
         //从备选栏中删除项
         private  void  Delete_Click( object  sender, EventArgs e)
         {
             if  ( this .SelectItemList.SelectedIndex < 0)
                 return ;
             this .SelectItemList.Items.RemoveAt( this .SelectItemList.SelectedIndex);
         }
         //确定添加事务到挖掘准备框
         private  void  Submit_Click( object  sender, EventArgs e)
         {
             insertform();
         }
         private  void  insertform()
         {
             trans t =  new  trans();
             t.tID = GetTID();
             t.items = GetItemList();
             AddItemToDataView(t);
             tData.Add(t);
         }
         
         private  void  AddItemToDataView(trans t)
         {
             string  transLine =  "" ;
             //添加TID
             transLine = transLine + t.tID +  "\t" ;
             //添加商品ID列表
             for  ( int  i = 0; i < t.items.Count; i++)
             {
                 transLine = transLine + t.items[i].ToString() +  "," ;
             }
             transLine = transLine +  "\n" ;
             this .TDataView.Items.Add(transLine);
         }     
         //取消添加事务到挖掘准备框
         private  void  Cancel_Click( object  sender, EventArgs e)
         {
             this .SelectItemList.Items.Clear();
         }
         #endregion
         //计算下一项
         private  void  Next_Click( object  sender, EventArgs e)
         {
             if  (finish ==  true )
             {
                 this .Next.Text =  "计算下一步" ;
                 Init();
                 return ;
             }
             
             ArrayList OldL =  new  ArrayList(L0);
             //增加步骤计数，用来决定计算Ｃ或者是Ｌ。
             step++;
             //计算L并显示L视图
             #region           
             //计算L
             if  (step % 2 == 1)
             {
                 //找出频繁1项集L1
                 if  (step == 1)
                 {
                     //当前事务总数tData.Count
                     for  ( int  i = 0; i < tData.Count; i++)
                     {
                         trans t = (trans)tData[i];
                         //当前一个事务中的项的总数t.items.Count
                         for  ( int  j = 0; j < t.items.Count; j++)
                         {
                             bool  flag =  true ;
                             //判断一下当前项是不是已经被计算过支持度，L0用于存放频繁K项集（items和sup）
                             for  ( int  k = 0; k < L0.Count; k++)
                             {
                                 string  mda=((itemAndSup)L0[k]).items[0].ToString();
                                 if  (((itemAndSup)L0[k]).items[0] == t.items[j])
                                 {
                                     flag =  false ;
                                     break ;
                                 }
                             }
                             if  (flag ==  false )
                                 continue ;
                             ArrayList items =  new  ArrayList();
                             items.Add(t.items[j]);
                             int  sup = FindItemSup(items);
                             if  (sup >= minSup)
                             {
                                 itemAndSup temp =  new  itemAndSup();
                                 temp.sup = sup;
                                 temp.items = items;
                                 L0.Add(temp);
                             }
                         }
                     }
                 }
                 //通过Ck来确定Lk
                 else
                 {
                     L0.Clear();
                     for  ( int  i = 0; i < C0.Count; i++)
                     {
                         itemAndSup temp = (itemAndSup)C0[i];
                         if  (temp.sup >= minSup)
                             L0.Add(temp);
                     }
                 }
                 //更新L的视图               
                     if  (L0.Count != 0)
                     {
                         this .LResultView.Items.Clear();
                         this .LResultView.Items.Add( "项集\t支持度计数\n" );
                         for  ( int  i = 0; i < L0.Count; i++)
                         {
                             ArrayList items = ((itemAndSup)L0[i]).items;
                             int  sup = ((itemAndSup)L0[i]).sup;
                             string  LResultLine =  "" ;
                             for  ( int  j = 0; j < items.Count; j++)
                             {
                                 LResultLine = LResultLine + items[j].ToString() +  "," ;
                             }
                             LResultLine = LResultLine +  "\t"  + sup +  "\n" ;
                             this .LResultView.Items.Add(LResultLine);
                         }
                         this .resultBox.Items.Clear();
                         this .resultBox.Items.Add( "项集\t支持度计数\n" );
                         for  ( int  i = 0; i < OldL.Count; i++)
                         {
                             ArrayList items = ((itemAndSup)OldL[i]).items;
                             int  sup = ((itemAndSup)OldL[i]).sup;
                             string  ResultLine =  "" ;
                             for  ( int  j = 0; j < items.Count; j++)
                             {
                                 ResultLine = ResultLine + items[j].ToString() +  "," ;
                             }
                             ResultLine = ResultLine +  "\t"  + sup +  "\n" ;
                             this .resultBox.Items.Add(ResultLine);
                         }
                     }
                     else
                     {                       
                         this .resultBox.Items.Clear();
                         this .resultBox.Items.Add( "项集\t支持度计数\n" );
                         for  ( int  i = 0; i < OldL.Count; i++)
                         {
                             ArrayList items = ((itemAndSup)OldL[i]).items;
                             int  sup = ((itemAndSup)OldL[i]).sup;
                             string  ResultLine =  "" ;
                             for  ( int  j = 0; j < items.Count; j++)
                             {
                                 ResultLine = ResultLine + items[j].ToString() +  "," ;
                             }
                             ResultLine = ResultLine +  "\t"  + sup +  "\n" ;
                             this .resultBox.Items.Add(ResultLine);
                         }
                         OldL.Clear();
                         this .LResultView.Items.Clear();
                         this .LResultView.Items.Add( "项集\t支持度计数\n" );
                         for  ( int  i = 0; i < OldL.Count; i++)
                         {
                             ArrayList items = ((itemAndSup)OldL[i]).items;
                             int  sup = ((itemAndSup)OldL[i]).sup;
                             string  LResultLine =  "" ;
                             for  ( int  j = 0; j < items.Count; j++)
                             {
                                 LResultLine = LResultLine + items[j].ToString() +  "," ;
                             }
                             LResultLine = LResultLine +  "\t"  + sup +  "\n" ;
                             this .LResultView.Items.Add(LResultLine);
                         }
                     }
                 //更新L说明
                     if  (L0.Count != 0)
                         this .Msg.Text =  "比较候选支持度计数与最小支持度计数" ;
                     else
                     {
                         this .Msg.Text =  "由于L为空，算法终止" ;
                         this .Next.Text =  "完成（重新开始）" ;
                         finish =  true ;
                     }
             }
             #endregion
             //计算C并显示C视图
             #region          
             //计算C
             else
             {
                 //通过将Lk-1与Lk-1自身连接产生Ck，Lk-1中的items项的顺序已经排好为由小到大
                 C0.Clear();
                 for  ( int  i = 0; i < L0.Count; i++)
                 {
                     //items0(Lk)与Lk合并
                     ArrayList items0 = ((itemAndSup)L0[i]).items;
                     //将可以合并到items0的值items[k]添加到addItem中，以防止后面重复添加
                     ArrayList addItem =  new  ArrayList();
                     for  ( int  j = 0; j < L0.Count; j++)
                     {
                         //当自身与自身组合时，跳过这一步
                         if  (j == i)
                             continue ;
                         //Lk本身，将被合并到items0
                         ArrayList items1 = ((itemAndSup)L0[j]).items;
                         for  ( int  k = 0; k < items1.Count; k++)
                         {
                             //当前items1[k]是否比items0中最后一个数值小，如果小的话则进行下一次循环
                             if  ((( string )items1[k]).CompareTo(( string )items0[items0.Count - 1]) <= 0)
                                 continue ;
                             //如果items[1]已经合并到items0的话，则进行下一次循环
                             if  (addItem.Contains(items1[k]))
                                 continue ;
                             //对items0+items1[k]进行Ck与Lk-1测试，判断Ck是否是Lk-1的超集，
                             //如果不是超集 则合并后的项集的支持度肯定小于最小支持度阈值
                             bool  mmm = ItemTest(items0, items1[k]);
                             if  (ItemTest(items0, items1[k])) //测试通过
                             {
                                 ArrayList items =  new  ArrayList(items0);
                                 items.Add(items1[k]);
                                 items.Sort();
                                 int  sup = FindItemSup(items);
                                 itemAndSup temp =  new  itemAndSup();
                                 temp.items = items;
                                 temp.sup = sup;
                                 C0.Add(temp);
                                 addItem.Add(items1[k]);
                             }
                         }
                     }
                 }
                 //更新C视图
                     this .CResultView.Items.Clear();
                     this .CResultView.Items.Add( "项集\t支持度计数\n" );
                     for  ( int  i = 0; i < C0.Count; i++)
                     {
                         ArrayList items = ((itemAndSup)C0[i]).items;
                         int  sup = ((itemAndSup)C0[i]).sup;
                         string  CResultLine =  "" ;
                         for  ( int  j = 0; j < items.Count; j++)
                         {
                             CResultLine = CResultLine + items[j].ToString() +  "," ;
                         }
                         CResultLine = CResultLine +  "\t"  + sup +  "\n" ;
                         this .CResultView.Items.Add(CResultLine);
                     }              
                 //更新C视图说明
                     if  (C0.Count != 0)
                         this .Msg.Text =  "由L产生C，并扫描D，对每个候选计数" ;
                     else
                     {
                         this .Msg.Text =  "由于C为空，算法终止" ;
                         this .Next.Text =  "完成（重新开始）" ;
                         finish =  true ;
                     }
             }
             #endregion
         }
         //计算项集的支持度Sup
         private  int  FindItemSup(ArrayList item)
         {
             //初始化支持度为0
             int  count = 0;
             //对每一个事务进行查询
             for  ( int  i = 0; i < tData.Count; i++)
             {
                 trans t = (trans)tData[i];
                 bool  flag =  true ;
                 //将传递过来的项集，将项集中的每一个项与事务进行对比，查看是否存在于事务中               
                 for  ( int  j = 0; j < item.Count; j++)
                 {
                     //只要有一个项不存在于事务中，flag=0，则此项集不存于事务中
                     if  (!(t.items.Contains(item[j])))
                     {
                         flag =  false ;
                         break ;
                     }
                 }
                 //如果项集存在于事务中，则支持度加1
                 if  (flag ==  true )
                     count++;
             }
             //返回支持度计数
             return  count;
         }
         //对items0+items1[k]进行Ck与Lk-1测试，判断Ck是否是Lk-1的超集，如果是超集，则返回true，如果不是则返回false
         private  bool  ItemTest(ArrayList items, object  addItem)
         {           
             for  ( int  i = 0; i < items.Count;i++ )
             {
                 ArrayList newItems =  new  ArrayList(items);
                 newItems.RemoveAt(i);
                 newItems.Add(addItem);
                 newItems.Sort();
                 for  ( int  j = 0; j < L0.Count; j++)
                 {
                     bool  flag2= true ;
                     ArrayList tempItems = ((itemAndSup)L0[j]).items;
                     for  ( int  k = 0; k < tempItems.Count;k++ )
                     {
                         if  (newItems[k]!=tempItems[k])
                         {
                             flag2 =  false ;                       
                             break ;
                         }
                     }
                     //只要有一个存在于Lk-1中即可返回true，结束本测试
                     if  (flag2== true )
                     {
                         return  true ;
                     }
                 }               
             }
             //如果所有对比均进行完毕，则返回false
             return  false ;          
         }
         //推导项里添加项集
         private  void  btnAddConf_Click( object  sender, EventArgs e)
         {
             if  ( this .confList.SelectedIndex < 0)
                 return ;
             for  ( int  i = 0; i <  this .confEnd.Items.Count; i++)
             {
                 if  ( this .confEnd.Items[i] ==  this .confList.SelectedItem)
                     return ;
             }
             this .confEnd.Items.Add( this .confList.SelectedItem);
         }
         //推导项里删除项
         private  void  btnCancelConf_Click( object  sender, EventArgs e)
         {
             if  ( this .confEnd.SelectedIndex < 0)
                 return ;
             this .confEnd.Items.RemoveAt( this .confEnd.SelectedIndex);
         }
         //关联项添加项集
         private  void  btnConf_Click( object  sender, EventArgs e)
         {
             if  ( this .ListConf.SelectedIndex < 0)
                 return ;
             for  ( int  i = 0; i <  this .EndConf.Items.Count; i++)
             {
                 if  ( this .EndConf.Items[i] ==  this .ListConf.SelectedItem)
                     return ;
             }
             this .EndConf.Items.Add( this .ListConf.SelectedItem);
         }
         //关联项删除项
         private  void  BtnConfCancel_Click( object  sender, EventArgs e)
         {
             if  ( this .EndConf.SelectedIndex < 0)
                 return ;
             this .EndConf.Items.RemoveAt( this .EndConf.SelectedIndex);
         }
         //计算置信度
         private  void  confBtn_Click( object  sender, EventArgs e)
         {
             float  sumconf = FindItemSup(insertSumConf());
             float  refconf = FindItemSup(insertConf());
             float  result = (sumconf / refconf) * tData.Count;
             txtConfidence.Text = (result).ToString();
         }
         //获取推导项集
         private  ArrayList insertConf()
         {
             ArrayList items =  new  ArrayList();
             for  ( int  i = 0; i <  this .confEnd.Items.Count; i++)
             {
                 string  itemID =  this .confEnd.Items[i].ToString();
                 items.Add(itemID);
             }
             items.Sort();
             return  items;
         }
         //获取关联项集
         private  ArrayList insertSumConf()
         {
             ArrayList items =  new  ArrayList();
             for  ( int  i = 0; i <  this .EndConf.Items.Count; i++)
             {
                 string  itemID =  this .EndConf.Items[i].ToString();
                 items.Add(itemID);
             }
             items.Sort();
             return  items;
         }
     }
}

转载于:https://www.cnblogs.com/yechanglv/p/6923402.html

数据挖掘算法之C4.5
shanhai3000的博客
07-17 1140
算法描述 C4.5算法是机器学习和数据挖掘领域中用于处理分类问题的算法。该算法是有监督学习类型的，即：给定一个数据集，每条记录都由一组特征来描述，每条记录仅属于一个标签，在给定的数据集上运行C4.5算法可以学习到一个从特征值到标签的映射，进而可以使用该映射去分类未知的（无标签）数据集。 C4.5算法源于ID3（iterative dichotomizers 3，迭代分解器系列算法的第三代），是一种决策树诱导算法。 所有的树诱导方法大都遵循一种递归模式。即，用根结点表示一个给定的数据集；然后，从根结点开始，在
关联规则挖掘：分布式关联规则挖掘算法
kkchenjj的博客
07-14 1031
在关联规则挖掘中，频繁项集（Frequent Itemset）是指在数据集中出现频率不低于预设阈值的项集。这里的“频率”通常指的是支持度（Support），即数据集中包含该项集的交易数占总交易数的比例。例如，考虑一个超市的销售数据，如果“面包”和“牛奶”这个组合在所有交易中至少出现了5%的次数，那么我们可以说“面包”和“牛奶”构成了一个频繁项集。MapReduce是一种编程模型，用于处理和生成大规模数据集。其核心思想是将大规模数据处理任务分解为可以并行处理的小任务，这些小任务可以在大量计算机上并行执行。
C4.5关联规则挖掘算法
05-23
这是我毕业设计的题目。该程序虽然代码有点乱，但是功能很全（连续属性离散化等功能都有实现）。实验数据和训练数据都比较大，可以体现这个算法的真正效率及准确率。
关联规则挖掘算法：Apriori
haoshen's blog
09-21 4065
所谓的关联规则（Association Rule）主要是指数据中的并发关系，最典型的的应用就是对购物篮的分析，发现所有的老爸买尿布的时候都会买啤酒。     关联规则挖掘中有一些容易混淆的术语，详见http://blog.sina.com.cn/s/blog_4d8d6303010009kb.html ，这里有两个很重要的概念：支持度和置信度。通俗的说，支持度就是所有的顾客中有多少顾客买了尿布和
关联规则挖掘（Association Rule (AR) algorithms）
wydbyxr的博客
10-22 1364
关联规则挖掘（Association Rule (AR) algorithms）
十大经典数据挖掘算法之C4.5算法
零度的博客专栏
08-10 2538
C4.5是一系列用在机器学习和数据挖掘的分类问题中的算法。它的目标是监督学习：给定一个数据集，其中的每一个元组都能用一组属性值来描述，每一个元组属于一个互斥的类别中的某一类。C4.5的目标是通过学习，找到一个从属性值到类别的映射关系，并且这个映射能用于对新的类别未知的实体进行分类。C4.5由J.Ross Quinlan在ID3的基础上提出的。ID3算法用来构造决策树。决策树是一种类似流程图的树结构
超详细！基于 Apriori 关联规则挖掘算法实现商品购物篮分析（数据+代码+5k字项目报告）
03-15
Apriori 算法是关联规则挖掘的经典算法之一，尤其在零售业中的商品购物篮分析中应用广泛。本项目深入探讨了如何利用 Apriori 算法来揭示消费者购买行为的模式。 首先，我们要理解 Apriori 算法的基本原理。Apriori ...
关联规则挖掘算法apriori算法的实现
10-26
Apriori算法是关联规则挖掘中最经典、最广泛使用的算法之一，由Rakesh Agrawal和Ramakrishnan Srikant在1994年提出。这个算法主要目标是从交易数据库中找出频繁项集和强关联规则。 首先，我们来理解“关联规则”。...
数据挖掘经典算法之：C4.5算法
lu_yunjie的专栏
08-03 2313
一.C4.5算法 C4.5算法是对ID3算法的一种改进，所以，首先我们来看ID3算法。 ID3算法是在决策树各个结点上应用信息增益准则来选择特征，递归地构建决策树。 决策树：是一种基本的分类与回归方法，一种分类决策模型，是一种树形结构，该模型具有可读性，分类速度快的优点。决策树由结点（内部结点、叶结点）和有向边组成。内部结点表示特征或属性，叶结点表示类或结论。决策树如下图所示：其中圆点表示特...
超全数据挖掘面试笔试题（附答案）
热门推荐
ggzhou的个人笔记
09-18 7万+
一、单选题（共80题） ( D )的目的缩小数据的取值范围，使其更适合于数据挖掘算法的需要，并且能够得到和原始数据相同的分析结果。 A.数据清洗       B.数据集成 C.数据变换       D.数据归约 某超市研究销售纪录数据后发现，买啤酒的人很大概率也会购买尿布，这种属于数据挖掘的哪类问题？(A)    A. 关联规则发现       B. 聚类    C. 分类      
十大经典算法之Apriori
huiqin08的博客
05-07 1万+
数据挖掘十大经典算法：KNN、C4.5、Naive Bayes、CART、SVM、Kmeans、PageRank、AdaBoost、EM、Apriori Aprior
C4.5算法的分析和实现
john_dw的专栏
05-08 1万+
基于决策树技术的数据挖掘方法分析和研究 ——C4.5算法的分析和实现 摘要 大数据时代已经到来，对数据的处理越来越受到人们的关注，人们迫切需要海量数据背后的重要信息和知识，发现数据中存在的关系和规则，获取有用的知识，并且根据现有数据对未来的发展做出预测。决策树分类算法C4.5算法是数据挖掘中最常用、最经典的分类算法，能够以图形化的形式表现挖掘的结果，从而方便于使用者快速做出决定或预测。决策树
C4.5——信息增益率
12-30 7626
说明一下如何计算信息增益率。 熟悉了ID3算法后，已经知道如何计算信息增益，计算公式如下所示（来自Wikipedia）： 或者，用另一个更加直观容易理解的公式计算： 按照类标签对训练数据集D的属性集A进行划分，得到信息熵： 按照属性集A中每个属性进行划分，得到一组信息熵： 计算信息增益 然后计算信息增益，即前者对后者做差，得到属性集合A一
关联规则挖掘算法-apriori
Enjoy the pleasure in the ocean of big data
01-12 635
关联分析关联分析即从数据集中发现项之间的隐藏关系。apriori算法主要是基于频繁项集的关联分析。 关联规则挖掘有两个步骤： 寻找频繁项集 从频繁项集产生关联规则 apriori性质任一频繁项集的所有非空子集也必须是频繁项集。这个项集可以在生成k-itemset的候选项时，如果这个候选项的（k-1）子集中有某个子集不存在（k-1）-itemset中，那么这个候选项直接删除，即不是k-itemset
cloudhsm-jvm-1.4.51-sources.jar
09-13
cloudhsm-jvm-1.4.51-sources.jar
sparkling-water-doc_2.12-3.42.0.3-1-3.4.jar
最新发布
09-13
sparkling-water-doc_2.12-3.42.0.3-1-3.4.jar
backupgateway-jvm-1.3.35-sources.jar
09-13
backupgateway-jvm-1.3.35-sources.jar
关系型数据库多维关联规则挖掘算法研究
多维关联规则挖掘算法是一种在关系型数据库中发现数据项之间有趣关系的技术，这些关系通常表现为频繁模式、关联、相关性或结构化模式等形式。关联规则挖掘最初应用于市场篮子分析，目的是为了发现顾客购买商品之间的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值