精华内容
下载资源
问答
  • Eclat算法 Eclat算法 Eclat算法 Eclat算法 Eclat算法
  • 频繁项集挖掘的Eclat算法 要编译代码,请在控制台中输入:make 制作了一个“主”可执行文件。 要运行程序,请在控制台中输入:./main -f inputFile -s minsup [-p] "-f inputFile" is a group. "-s minsup" is a...
  • Eclat算法Python实现

    2016-06-01 21:48:56
    该资源是Eclat算法Python实现代码,简洁实用。
  • Eclat BFC-crx插件

    2021-04-04 09:26:13
    改善了Eclat BFC用户体验 这个扩展改善了BFC亮度用户体验。 它允许自动登录,无论您是学生,父母还是老师。 它还可以计算平均值,并将其与音符的着色进行比较。 此外,由于此扩展,您将不会在错误页面上停留,您将在...
  • 关联规则eclat,逻辑示意版本,非类
  • Apriori和ECLAT应用程序构建推荐系统(产品分配策略) 经过训练的关联规则模型(Apriori和ECLAT)可以找到法国超市的顾客在一周内购买的最相关商品。 数据集上的7501行中的每一行代表唯一客户在一周内购买的商品。 ...
  • 关联分析eclat 类版本,简单调整即可用
  • 关联规则ECLAT算法

    2020-10-08 17:14:20
    Eclat算法 Eclat算法是一种基于集合交集的深度优先搜索算法,它适用于具有局部性增强特性的顺序执行和并行执行。 与fp-growth 和apriori算法不同,Eclat算法加入了倒排的思想,具体就是将事务数据中的项作为key,每...

    Eclat算法

    Eclat算法是一种基于集合交集的深度优先搜索算法,它适用于具有局部性增强特性的顺序执行和并行执行。

    与fp-growth 和apriori算法不同,Eclat算法加入了倒排的思想,具体就是将事务数据中的项作为key,每个项对应的事务ID作为value。

    举个例子

    假设数据集如下所示:

    假设支持度为50%,置信度为70%

    则最小支持度为:50%×6(TID个数)=3

    表一

    TIDitems
    1A,B,C
    2A,B
    3A
    4A,C
    5B,C,D
    6A,B

    Eclat算法的倒排思想,将表格变为:

    表二

    item(items中的单个元素)Tids(TID的合集)
    A1,2,3,4,6
    B1,2,5,6
    C1,4,5
    D5

    通过转换后的倒排表可以加快频繁集生成速度。 其算法思想是 由频繁k项集求交集,生成候选k+1项集 。对候选k+1项集做裁剪,生成频繁k+1项集,再求交集生成候选k+2项集。如此迭代,直到项集归一。 根据上述数据的情况,我们先计算频繁1项集:

    通过倒排表格计算频率

    itemfreq(频率)
    A5
    B4
    C3
    D1

    去除小于最小支持度的item,则频繁1项集为:

    itemfreq(频率)
    A5
    B4
    C3

    根据算法思想:由频繁k项集求交集,生成候选k+1项集 。对候选k+1项集做裁剪,生成频繁k+1项集

    在一次扫描数据库后得到每个1项集的支持度, 而候选k项集的支持度就是在对k-1项集进行交集操作后得到的该k项集Tidset中元素的个数。设项集X, 其Tidset为T (X) ,项集Y, 其Tidset为T (Y) , 则X的支持度计数为|T (X) |;Y的支持度计数为|T (Y) |;由项集X和Y可以组成一个新的项集Z, 则Z的支持度计数为|T (X∩Y) |
    摘自:Eclat算法的分析及改进
    在中国知网查看:https://kns.cnki.net/KXReader/Detail?TIMESTAMP=637377711556093750&DBCODE=CJFD&TABLEName=CJFD2010&FileName=JSJC201023012&RESULT=1&SIGN=nsRsq9PWYElYKG40xJWphpMtntA%3d

    求频繁2项集步骤如下

    频繁1项集元素排列为{A,B}、{A,C}、{B,C}

    **{A,B}**的项集参照表二(倒排表格)

    item(items中的单个元素)Tids(TID的合集)
    A1,2,3,4,6
    B1,2,5,6

    其中TID:1,2,6共同存在,则{A,B}出现次数为3,满足最小支持度3。

    **{A,C}**的项集参照表二(倒排表格)

    item(items中的单个元素)Tids(TID的合集)
    A1,2,3,4,6
    C1,4,5

    其中TID:1,4共同存在,则{A,C}出现次数为2,不满足最小支持度3。

    **{B,C}**的项集参照表二(倒排表格)

    item(items中的单个元素)Tids(TID的合集)
    B1,2,5,6
    C1,4,5

    其中TID:1,5共同存在,则{B,C}出现次数为2,不满足最小支持度3。

    则频繁2项集为

    itemfreq(频率)
    {A,B}3

    依次类推求频繁3项集:

    但本题中,频繁2项集的元素就只有两个,不构成3项集,则不存在。

    展开全文
  • 为了有效挖掘历史监测数据中各监测指标之间的隐含关系,提高关联规则挖掘的效率,以井下瓦斯浓度、温度、风速等多个监测数据作为研究对象,提出一种基于Eclat算法的瓦斯灾害预警及数据分析模型,将检测到的瓦斯浓度、...
  • 基于Eclat算法的图书推荐系统仿真.pdf
  • 基于位存储Tid的CPU并行化Eclat算法.pdf
  • 数据挖掘 Apriori、Eclat、Charm 实施需要工作
  • 提出了一种基于限制属性连接并具有垂直数据格式的关联规则算法i-Eclat算法。i-Eclat算法通过转换资源池节点状态数据格式、建立非频繁2-项集以减少连接次数,并构建信息存储结构体来限制冗余属性连接。实验表明,所...
  • 基于Apriori、FP-Growth及Eclat算法的频繁模式挖掘源程序 一、DataMiningApriori程序 用eclipse打开,把三个测试数据mushroom、accidents和T10I4D100K放置 在F:\DataMiningSample\FPmining文件夹下面,即可运行 二、...
  • 通过对Spark大数据平台以及Eclat算法的深入分析,提出了基于Spark的Eclat算法(即SPEclat)。针对串行算法在处理大规模数据时出现的不足,该方法在多方面进行改进:为减少候选项集支持度计数带来的损耗,改变了数据...
  • eclat-源码

    2021-03-27 16:16:04
    自述文件 该自述文件通常会记录启动和运行应用程序所需的所有步骤。 您可能要讲的内容: Ruby版本 系统依赖 配置 数据库创建 数据库初始化 如何运行测试套件 服务(作业队列,缓存服务器,搜索引擎等) ...
  • 将散列表与布尔矩阵相结合,提出了一种基于散列布尔矩阵的Eclat改进算法,通过提高求交集的速度来加快整个算法生成频集的过程。实验结果表明,改进的Eclat算法在计算性能和时间效率上均优于传统算法。
  • 基于Spark的并行Eclat算法实现,何海,王柏,频繁项集挖掘是数据挖掘的一项重要任务。而随着大数据时代的到来,数据规模增速惊人,已非传统的挖掘算法所能胜任。而应对上述问
  • 【R语言】频繁项集挖掘之Eclat算法

    千次阅读 2019-01-25 22:53:40
    频繁项集挖掘之Eclat算法 1.Eclat算法 Eclat算法用于执行项集挖掘。项集挖掘让我们在数据中找到频繁的模式,就像消费者购买牛奶一样,他也会购买面包。这种类型的模式称为关联规则,用于许多应用领域。 Eclat算法...

    频繁项集挖掘之Eclat算法


    1.Eclat算法

    Eclat算法用于执行项集挖掘。项集挖掘让我们在数据中找到频繁的模式,就像消费者购买牛奶一样,他也会购买面包。这种类型的模式称为关联规则,用于许多应用领域。

    Eclat算法的基本思想是使用tidset交集来计算候选项集的支持,从而避免生成前缀树中不存在的子集。它最初是由Zaki,Parthasarathy等人提出的。

    算法

    Eclat算法是递归定义的。初始调用时使用所有单个项及其tidsets。在每次调用中,函数IntersectTidsets将验证每个项集-tidset对{\displaystyle \left\langle {X,t(X)}\right\rangle }与所有的其他对{\displaystyle \left\langle {Y,t(Y)}\right\rangle },以生成新的候选集{\displaystyle N_{XY}}。如果新的候选集是频繁的,它将被添加到集合{\displaystyle P_{X}}中。然后,迭代地,它将找到所有在X的分支上的频繁项集。该算法搜索使用深度优先搜索策略DFS以发现所有的频繁项集。

    实现

    Eclat算法可以在R系统的arule包中找到。

    用法

    eclat(data, parameter = NULL, control = NULL)

    参数

    data

    类事务或任何可以强制转换为事务的任何数据集结构对象(例如,二分类矩阵,数据框).

    parameter

    ECparameter类或命名列表的对象 (默认值为: 支持度 0.1 和 最大长度 5)

    control

    ECcontrol类或算法控件的命名列表的对象。

    Value

    返回类itemsets的一个对象

    示例

    data("Adult")
    
    ## Mine itemsets with minimum support of 0.1.
    itemsets <- eclat(Adult, parameter = list(supp = 0.1, maxlen = 15))

    可视化

    arules包为itemset实现了一些可视化方法,这些方法是eclat算法的返回类型。这里有些例子:

    示例1:

    library(arules)
    data("Adult") 
    
    ## Mine frequent itemsets with Eclat.
    fsets <- eclat(Adult, parameter = list(supp = 0.5))
    
    ## Display the 5 itemsets with the highest support.
    fsets.top5 <- sort(fsets)
    inspect(fsets.top5)
    
    ## Get the itemsets as a list
    as(items(fsets.top5), "list")
    
    ## Get the itemsets as a binary matrix
    as(items(fsets.top5), "matrix")
    
    ## Get the itemsets as a sparse matrix, a ngCMatrix from package Matrix.
    ## Warning: for efficiency reasons, the ngCMatrix you get is transposed
    as(items(fsets.top5), "ngCMatrix")

    示例2:

    ## Create transaction data set.
    data <- list(
      c("a","b","c"),
      c("a","b"),
      c("a","b","d"),
      c("b","e"),
      c("b","c","e"),
      c("a","d","e"),
      c("a","c"),
      c("a","b","d"),
      c("c","e"),
      c("a","b","d","e")
    )
    
    t <- as(data, "transactions")
    
    ## Mine itemsets with tidLists.
    f <- eclat(data, parameter = list(support = 0, tidLists = TRUE))
    
    ## Get dimensions of the tidLists.
    dim(tidLists(f))
    
    ## Coerce tidLists to list.
    as(tidLists(f), "list")
    
    ## Inspect visually.
    image(tidLists(f))
    
    ##Show the Frequent itemsets and respectives supports
    inspect(f)

    示例2的结果:

    > inspect(f)
         items     support count
    [1]  {b,c,e}   0.1     1    
    [2]  {a,b,c}   0.1     1    
    [3]  {a,c}     0.2     2    
    [4]  {b,c}     0.2     2    
    [5]  {c,e}     0.2     2    
    [6]  {a,b,d,e} 0.1     1    
    [7]  {a,d,e}   0.2     2    
    [8]  {b,d,e}   0.1     1    
    [9]  {a,b,d}   0.3     3    
    [10] {a,d}     0.4     4    
    [11] {b,d}     0.3     3    
    [12] {d,e}     0.2     2    
    [13] {a,b,e}   0.1     1    
    [14] {a,e}     0.2     2    
    [15] {b,e}     0.3     3    
    [16] {a,b}     0.5     5    
    [17] {a}       0.7     7    
    [18] {b}       0.7     7    
    [19] {e}       0.5     5    
    [20] {d}       0.4     4    
    [21] {c}       0.4     4

    用例

    要查看使用Eclat算法的一些真实示例,将使用来自northwind数据库的一些数据。 northwind数据库可免费下载并代表企业的数据。 在此示例中,将使用数据库中的表顺序详细信息。 订单明细表用于将订单与产品相关联(以n到n的关系)。 Eclat算法将用于从该数据中查找频繁模式,以查看是否有任何产品一起购买。

    脚本

    给定来自northwind数据库的订单详细信息表中的数据,找到支持= 0.1且长度至少为2的所有频繁项集。

    输入数据

    订单明细表包含以下字段:

    ID:主键

    Order ID: 来自订单表的外键

    Product ID:来自产品表的外键

    Quantity:购买数量

    Discount:提供的折扣

    Unit Price:产品单价

    要使用这些数据,需要进行一些预处理。 该表可能有许多属于同一订单的行,因此表的转换方式使得一个订单的所有行只变成新表中包含属于该订单的产品的产品ID的一行。 字段ID,订单ID,数量,折扣和单价已被丢弃。 数据保存在名为northwind-orders.txt的txt文件中。 该文件的编写方式可以作为R中的列表对象加载。

    实现

    要运行该示例,需要在R中加载包arules。

    首先,将数据加载到R中的列表对象中

    ## 1041 transactions is loaded, the listing below was shortened
    ## some duplicates transactions was introduced to produce some results for the algorithm
    data = list(
     c("2","3","4","6","7","8","10","12","13","14","16","20","23","32","39","41","46","52","55","60","64","66","73","75","77"),
     c("11","42","72"),
     c("14","51"),
     c("41","51","65"),
     c("22","57","65"),
     ...)

    其次,使用eclat算法。

    >itemsets <- eclat(data, parameter = list(support = 0.1, minlen=2, tidLists = TRUE, target="frequent itemsets"))
    parameter specification:
     tidLists support minlen maxlen            target   ext
         TRUE     0.1      2      5 frequent itemsets FALSE
    
    algorithmic control:
     sparse sort verbose
          7   -2    TRUE
    
    eclat - find frequent item sets with the eclat algorithm
    version 2.6 (2004.08.16)         (c) 2002-2004   Christian Borgelt
    create itemset ... 
    set transactions ...[78 item(s), 1041 transaction(s)] done [0.00s].
    sorting and recoding items ... [3 item(s)] done [0.00s].
    creating bit matrix ... [3 row(s), 1041 column(s)] done [0.00s].
    writing  ... [4 set(s)] done [0.00s].
    Creating S4 object  ... done [0.00s].
    

    输出数据

    itemsets对象保存eclat算法执行的输出。如上所示,生成了4组。要查看结果,可以使用它:

    >inspect(itemsets)
      items   support
    1 {11,           
       42,           
       72}  0.1940442
    2 {42,           
       72}  0.1940442
    3 {11,           
       42}  0.1940442
    4 {11,           
       72}  0.1959654

    分析

    如上所述,作为eclat算法的结果,存在4个频繁项目集。 此输出是由数据中多次复制事务{11,42,72}引起的。 结果表明,元组{11,42,72},{42,72}和{11,42}的支持率为19,40%; 而元组{11,72}的支持率为19,60%。

    产品编号11,42和72分别代表产品Queso Cabrales,Singaporean Hokkien Fried Mee和Mozzarella di Giovanni。 因此,eclat算法的输出表明了购买这些物品的强烈频繁商店模式。

    变化

    PPV, PrePost, and FIN 算法

    这三种算法由Deng等[1] [2] [3]提出,并基于三种新颖的数据结构,分别称为Node-list [1],N-list [2]和Nodeset [3]。 频繁项集的挖掘过程。 它们是FP树中的节点集,每个节点使用预先顺序遍历和后序遍历进行编码。 与节点列表相比,N列表和节点集更有效。 这导致PrePost [2]和FIN [3]的效率高于PPV [1]的效率。 有关详细信息,请参见[1] [2] [3]。

    References[edit]

    • Hahsler, M.; Buchta, C.; Gruen, B. & Hornik, K. arules: Mining Association Rules and Frequent Itemsets. 2009.
    • Hahsler, M.; Gruen, B. & Hornik, K. arules -- A Computational Environment for Mining Association Rules and Frequent Item Sets. Journal of Statistical Software, 2005, 14, 1-25
    • Mohammed Javeed Zaki, Srinivasan Parthasarathy, Wei Li. A Localized Algorithm for Parallel Association Mining. SPAA 1997: 321-330.
    • Mohammed Javeed Zaki, Srinivasan Parthasarathy, Mitsunori Ogihara, Wei Li. New Algorithms for Fast Discovery of Association Rules. KDD 1997: 283-286.
    • Mohammed Javeed Zaki, Srinivasan Parthasarathy, Mitsunori Ogihara, Wei Li. Parallel Algorithms for Discovery of Association Rules. Data Min. Knowl. Discov. 1(4): 343-373 (1997).
    • Christian Borgelt (2003) Efficient Implementations of Apriori and Eclat. Workshop of Frequent Item Set Mining Implementations (FIMI 2003, Melbourne, FL, USA).
    1. ↑ Jump up to:a b c d Deng, Z. & Wang, Z. A New Fast Vertical Method for Mining Frequent Patterns [1]. International Journal of Computational Intelligence Systems, 3(6): 733 - 744, 2010.
    2. ↑ Jump up to:a b c d Deng, Z.; Wang, Z. & Jiang, J. A New Algorithm for Fast Mining Frequent Itemsets Using N-Lists [2]. SCIENCE CHINA Information Sciences, 55 (9): 2008 - 2030, 2012.
    3. ↑ Jump up to:a b c d Deng, Z. & Lv, S. Fast mining frequent itemsets using Nodesets [3]. Expert Systems with Applications, 41(10): 4505–4512, 2014.

     

    展开全文
  • 二十、Eclat算法介绍

    千次阅读 2020-03-24 11:05:02
    1. Eclat算法简介 数据格式 Apriori算法和FpGrowth都是从项集格式{TID: itemset}的事物集中挖掘频繁模式,其中TID是事物标识符,而itemset是事物TID中购买的商品。这种数据格式成为水平数据格式。 数据也可以用项-...

    1. Eclat算法简介

    数据格式

    • Apriori算法和FpGrowth都是从项集格式{TID: itemset}的事物集中挖掘频繁模式,其中TID是事物标识符,而itemset是事物TID中购买的商品。这种数据格式成为水平数据格式。
    • 数据也可以用项-TID集格式{item:TID_set}表示,其中item是项的名称,而TID_set是包含item的事物标识符的集合。这种数据格式称为垂直数据格式。

    等价变换类算法(Eclat算法)

    • Eclat算法加入了倒排的思想,具体就是将事务数据中的项作为key,每个项对应的事务ID作为value。
    • 只需对数据进行一次扫描,算法的运行效率会很高。

    Ecalt算法的过程

    • 通过扫描一次数据集,把水平格式的数据转换成垂直格式;
    • 项集的支持度计数简单地等于项集的TID集的长度;
    • 从k=1开始,可以根据先验性质,使用频繁k项集来构造候选(k+1)项集;
    • 通过取频繁k项集的TID集的交,计算对应的(k+1)项集的TID集。
    • 重复该过程,每次k增加1,直到不能再找到频繁项集或候选项集

    Eclat算法原理

    • 与fp-growth和apriori算法不同,Eclat算法加入了倒排的思想,具体就是将事务数据中的项作为key,每个项对应的事务ID作为value
      在这里插入图片描述

    • 水平格式转换成垂直格式
      通过转换后的倒排表可以加快频繁集生成速度。
      在这里插入图片描述

    • 计算频繁1项集,结果为
      在这里插入图片描述

    • 由频繁1项集生成频繁2项集
      在这里插入图片描述

    • 由频繁2项集生成频繁3项集

    频繁k项集生成频繁k+1项集的过程与由1项集生成2项集的过程完全一致。
    Eclat算法实例
    在这里插入图片描述

    2 算法实现过程

    在这里插入图片描述

    2.1 输出结果

    在这里插入图片描述

    3完整代码

    # -*- coding: utf-8 -*-
    import numpy as np
    from itertools import combinations
    
    # 读取数据集
    def read_data():
        dataset = [['Milk', 'Onion', 'Nutmeg', 'Kidney Beans', 'Eggs', 'Yogurt'],
                   ['Dill', 'Onion', 'Nutmeg', 'Kidney Beans', 'Eggs', 'Yogurt'],
                   ['Milk', 'Apple', 'Kidney Beans', 'Eggs'],
                   ['Milk', 'Unicorn', 'Corn', 'Kidney Beans', 'Yogurt'],
                   ['Corn', 'Onion', 'Onion', 'Kidney Beans', 'Ice cream', 'Eggs']]
        return dataset
    
    # eclat算法
    def eclat(transactions, min_support=0.35):
    
        combos_to_counts = {}
        for transaction in transactions:               # 变量交易记录
            goods = list(np.unique(transaction))       # 获取商品列表
            length = len(goods)
            for k in range(2, length + 1):
                k_combos = list(combinations(goods, k))
                for combo in k_combos:
                    if set(combo).issubset(transaction):
                        try:
                            combos_to_counts[combo] += 1
                        except KeyError:
                            combos_to_counts[combo] = 1
    
        # Calculate supports for combinations of goods
        #
        combo_support_vec = []
        for combo in combos_to_counts.keys():
            # 计算支持度
            support = float(combos_to_counts[combo]) / len(transactions)
            combo_support_vec.append((combo, support))
    
        # 按照支持度排序
        combo_support_vec.sort(key=lambda x: float(x[1]), reverse=True)
    
        # 第一列货物的列表,第二列为支持度
        with open("./eclat_out.tsv", "w") as fo:
            for combo, support in combo_support_vec:
    
                if support < min_support:
                    continue
                else:
                    print(combo, support)
                    fo.write(", ".join(combo) + "\t" + str(support) + "\n")
        fo.close()
    
    def main():
        transactions = read_data()
        eclat(transactions, min_support=0.6)
    
    if __name__ == '__main__':
        main()
    
    展开全文
  • 从垂直数据格式的角度出发,对频繁项集数据挖掘算法Eclat进行了分析,并从数据流的特性出发对其进行了分析。 随后,提出了一种新颖的边缘扩展计算模式。 在分析数据依存关系的基础上,根据边缘计算的新模式,提出了...
  • 基于Apriori、FP-Growth及Eclat算法的频繁模式挖掘源程序 一、DataMiningApriori程序 用eclipse打开,把三个测试数据mushroom、accidents和T10I4D100K放置 在F:\DataMiningSample\FPmining文件夹下面,即可运行 ...
  • Apriori 算法和FP-growth 都是从水平数据格式出发,获得频繁项集的方法, 本文将介绍一种从垂直数据出发得到频繁项集的算法 Eclat(Equivalence Class Transformation), Eclat的优势是只需扫描一遍完整的数据库, 劣势是...

    ​一. Eclat 是一种使用垂直数据出发得到频繁项集的算法

    Apriori 算法和FP-growth 都是从水平数据格式出发,获得频繁项集的方法, 本文将介绍一种从垂直数据出发得到频繁项集的算法 Eclat(Equivalence Class Transformation), Eclat的优势是只需扫描一遍完整的数据库, 劣势是,频繁项较多时的集合的交集运算会比较花费时间,且对计算资源需求较大
    本文采用《数据挖掘概念与技术》中的数据集,并使用该书中的结果验证代码结果的准确性 .
    可以在我们的 “数据臭皮匠” 中输入"第六章4" 拿到

    1.手动输入书中的数据

    data_ls ={'T100':['I1','I2','I5'],
        'T200':['I2','I4'],
        'T300':['I2','I3'],
        'T400':['I1','I2','I4'],
        'T500':['I1','I3'],
        'T600':['I2','I3'],
        'T700':['I1','I3'],
        'T800':['I1','I2','I3','I5'],
        'T900':['I1','I2','I3']}
    
    

    2.将水平数据格式转换为垂直数据格式

    def convert(data):
        """将水平数据格式转换为垂直数据格式"""
        data_vert = {}
        for tid,items in data_ls.items():
            for item in items:
                if frozenset({item}) not in data_vert:
                    data_vert[frozenset({item})] = {tid}
                else :
                    data_vert[frozenset({item})].add(tid)
        return data_vert
    
    
    # convert(data_ls)
    

    只需一次扫描, 就可以将水平数据格式转换为垂直数据
    在这里插入图片描述

    3.根据最小支持度阈值, 删除不满足最小支持度的项

    (书中设置的最小支持度为2,所有所有项都是频繁的)

    def drop_data(data):
        """根据阈值删除掉不频繁的项"""
        res = data.copy()
        for key in data :
            if len(data[key])<threshold_val:
                del res[key]
        return res
    
    # 删除不满足最小支持度的项
    # data_vert = drop_data(data_vert)
    # 得到频繁一项集 L1
    # L1 = [frozenset(key) for key in data_vert.keys()]
    # print('L1:',L1)
    

    4.根据频繁一项集得到候选2项集

    看过’Apriori 算法’的读者应该很熟悉上面这个函数, 这里和’Apriori 算法’ 中使用的aprioriGen 是逻辑是一致的, 只是返回值的形式有所改变

    def aprioriGen(Lk_1, k):  # creates Ck
        """ 根据k-1项集产生候选k项集
        Lk_1: k-1项集的列表
        k: k项集的k
        """
        res = {}
        lenLk_1 = len(Lk_1)  # k-1项集的长度
        for i in range(lenLk_1):
            for j in range(i + 1, lenLk_1):
                L1 = sorted(list(Lk_1[i]))  # k等于2时, 1项集取空, k等于3时,2项集取第一个元素, k等于4时,3项集取前两个元素
                L2 = sorted(list(Lk_1[j]))  # k等于2时, 1项集取空, k等于3时,2项集取第一个元素, k等于4时,3项集取前两个元素
    
                if L1[:k - 2] == L2[:k - 2]:  # 如果前k减2个元素相等 , 就将两几何求并
                    res[Lk_1[i]|Lk_1[j]]=[Lk_1[i],Lk_1[j]]  # set union
    
        return res
    
    # candidate = aprioriGen(L1, k=2)
    

    5.通过求交集计算每个候选2项集的支持度

    得到候选2项集以后, 需要通过求交集计算每个候选2项集的支持度,我们这里的候选2项集有10个元素, 分别求交集获得支持度后发现, 有8个元素的支持度是大于0的, 其中{I1,I4},{I3,I5} 的支持度为1

    def get_support(candidate_k_1,vert):
        """通过求交集获得候选k项集的支持度,并因此获得k项集"""
        res = {}
        for key,items in candidate_k_1.items():
            item1,item2 = items
            ss = vert[item1]&vert[item2]
    
            res[key] = ss
        return res
    
    
    
    # data_vert = get_support(candidate,data_vert)
    

    在这里插入图片描述

    6.通过循环计算频繁k项集

    通过循环计算频繁K项集,候选K+1项集, 候选K+1项集每个项的支持度,可以得到所有的频繁项集, 频繁3项集的结果如下图

    threshold_val = 2
    # 将水平数据格式转换为垂直数据格式
    data_vert = convert(data_ls)
    # 删除不满足最小支持度的项
    data_vert = drop_data(data_vert)
    # 得到频繁一项集 L1
    L1 = [frozenset(key) for key in data_vert.keys()]
    print('L1:',L1)
    
    res = []
    res.append(L1)
    # 获得候选2项集
    candidate = aprioriGen(L1, k=2)
    i=1
    while len(candidate):
        print(f'data_vert{i}:', data_vert)
        i+=1
        # 对候选2项集通过求交集计算支持度
        data_vert = get_support(candidate,data_vert)
        # 删除不满足支持度的项, 得到频繁2项集
        data_vert = drop_data(data_vert)
        if len(data_vert):
            L = [frozenset(key) for key in data_vert.keys()]
            res.append(L)
            print(f'L{i}:',L)
            candidate = aprioriGen(L, k=2)
        else:
            break
    

    在这里插入图片描述

    二. Eclat算法的总体流程

    Eclat算法的总体流程是比较简单且清晰的,首先通过扫描一次数据集, 把水平格式的数据转换为垂直格式.这个过程顺便也就把每个项的支持度计算出来了, 从k=1开始,可以根据先验性质,使用频繁k项集来构造k+1项集, 且可以通过取频繁k项集的交集计算对应k+1项集的支持度, 重复该过程,每次k增加1, 直到不能再找到频繁项集或候选项集.
    在这里插入图片描述
    更多精彩内容,请关注:数据臭皮匠 共中号
    作者:范小匠
    审核:灰灰匠
    编辑:森匠

    展开全文
  • Equivalence Class Transformation(Eclat)是频繁项挖掘和关联性分析的另外一种常用的算法,与Apriori和FP-growth不同的是,Eclat采用垂直数据格式。所谓的垂直数据格式,就是从对原有数据进行倒排。...
  • 关联规则挖掘算法-ECLAT

    千次阅读 2017-01-13 10:20:36
    ECLAT-等价类转换(Equivalent CLAss Transformation) ECLAT使用垂直数据格式挖掘频繁项集。垂直数据apriori算法和fp-growth算法都从TID项集格式(即{TID:itemset})的事务集中挖掘频繁模式,其中TID是事务标识符...
  • 【数据挖掘】关联规则之Eclat算法

    千次阅读 2019-01-24 20:11:27
    Eclat算法  前面介绍过的Apriori算法和FP-growth算法都是从TID-项集格式(即{TID:itemset})的事务集中挖掘频繁模式,其中TID是事务标识符,而itemset是事务TID中购买的商品。这种数据格式称为水平数据格式。...
  • eclat算法,报语法错误python,求大神解救,代入如下: import sys import time type = sys.getfilesystemencoding() from sys import argv def eclat(prefix, items): while items: i,itids = items.pop() ...
  • ECLAT关联规则挖掘 等价类转换关联规则挖掘算法的Python实现 我在无聊的时候写了这篇文章,并希望找到一个很好的算法来加快Cython的速度。 不幸的是,这个问题并不能轻易实现优化(而频繁模式挖掘的FP-tree方法要快...
  • Apriori、FP-Growth及Eclat算法

    千次阅读 2015-12-06 15:51:41
    注:本文转载自yangliuy http://blog.csdn.net/yangliuy/article/details/7494983 数据挖掘-关联分析频繁模式挖掘Apriori、FP-Growth及Eclat算法的JAVA及C++实现 一、Apriori算法  Apriori是非常经典的关联...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,817
精华内容 726
关键字:

eclat