设全集U = {a, b, c, d, e},其元素a,b, c, d, e称为项.

数据集:

D = [
    {a, b},
    {b, c, d},
    {d, e},
    {b, c, e},
    {a,b, c, d}
]

项的集合如{a,b}称为项集(cell), 包含k个项的集合称为k项集.

数据集D中包含项集A的集合占所有元素集的比例称为A的支持度(support).如{a}的支持度为2/5.

若项集满足人为设定的最小支持度,则称为频繁集.

频繁集的任意子集一定是频繁集, 非频繁集的超集一定为非频繁集.

定义关联规则{a} -> {b}的可信度(confidence)为:support({a} U {b}) / support({a}).

关联分析的目的在于寻找频繁集以及关联规则。

寻找频繁集

非频繁集的超集一定为非频繁集,我们从空集开始根据包含关系构建一棵树:

根据数据集创建单项集:

def createUnit(dataSet):  # create cell with one element
    universe = []
    for cell in dataSet:
        for item in cell:
            if not [item] in universe:
                universe.append([item])
    return map(frozenset, universe)

遍历每一个项集中的每一项,将项添加到全集中, 最后使用map由全集创建单项集.

使用frozenset而非set,是因为frozenset可以在dict中作为键, 而set不能.

从候选集中筛选频繁集:

def filterCandidates(dataSet, candidates, limit):
    cellCount = {}
    for cell in dataSet:
        for candidate in candidates:
            if candidate.issubset(cell):
                if not candidate in cellCount:
                    cellCount[candidate] = 1
                else:
                    cellCount[candidate] += 1
    cellNum = len(dataSet)
    selected = []
    supports = {}
    for cell in cellCount:
        support = float(cellCount[cell]) / cellNum
        if support >= limit:
            selected.insert(0, cell)
        supports[cell] = support
    return selected, supports

该方法接受三个参数, 数据集dataSet, 候选集列表candidates, 和最小支持度limit.

遍历dataSet中的所有项集,统计各候选集超集的个数, 用于计算候选集的支持度.

过滤所有候选集, 返回支持度达到要求的项集(频繁集).

根据k-1项集创建所有k项集:

def createKCell(origins, k):
    cells = []
    originCount = len(origins)
    for i in range(originCount):
        for j in range(i + 1, originCount):
            list1 = list(origins[i])[:k - 2]
            list2 = list(origins[j])[:k - 2]
            list1.sort()
            list2.sort()
            if list1 == list2:  # if first k-2 elements are equal
                cells.append(origins[i] | origins[j])  # set union
    return cells

该方法接受两个参数,k-1项集列表origins和k. 通过并集运算建立k项集.

从单项集开始寻找频繁集:

def apriori(dataMat, limit=0.5):
    units = createUnit(dataMat)
    dataSet = map(set, dataMat)
    origin, supports = filterCandidates(dataSet, units, limit)
    candidates = [origin]
    k = 2
    while (len(candidates[k - 2]) > 0):
        cellK = createKCell(candidates[k - 2], k)
        cellK, supportK = filterCandidates(dataSet, cellK, limit)
        supports.update(supportK)
        candidates.append(cellK)
        k += 1
    return candidates, supports

寻找关联规则

频繁集之间存在着关联规则:

实现filterRules方法获得可信度满足要求的规则, 每条规则用三元组来描述:(A, B, confidence)代表规则A->B的可信度为confidence.

def filterRules(cells, consequences, supports, bigRuleList, limit=0.7):
    prunedConsequences = []
    for consequence in consequences:
        confidence = supports[cells] / supports[cells - consequence]
        if confidence >= limit:
            rule = (cells - consequence, consequence, confidence)
            bigRuleList.append(rule)
            prunedConsequences.append(consequence)
return prunedConsequences

该方法接受5个参数:

  • cells:频繁集列表

  • consequences: 所有可放在规则右侧的元素组成的列表

  • supports: cells中各频繁集的支持度

  • bigRuleList: 已知规则的列表, 该方法会将满足要求的规则添加到该列表中

  • limit: 规则可信度的下限

该方法返回满足条件的规则的右侧元素组成的列表.

当规则右侧的元素的数目大于2时, 尝试对其进行合并:

def rulesFromConseq(cells, consequences, supports, bigRuleList, limit=0.7):
    m = len(consequences[0])
    if len(cells) > (m + 1):  # try further merging
        new_consequences = createKCell(consequences, m + 1)
        new_consequences = filterRules(cells, new_consequences, supports, bigRuleList, limit)
        if len(new_consequences) > 1:  # need at least two sets to merge
            rulesFromConseq(cells, new_consequences, supports, bigRuleList, limit)

该方法的参数与filterRules方法相同, 使用递归来实现.

利用上面两个工具函数来编写寻找关联规则的方法:

def generateRules(cells, supports, limit=0.7):
    bigRuleList = []
    for i in range(1, len(cells)):
        for cell in cells[i]:
            consequences = [frozenset([item]) for item in cell]
            if i > 1:
                rulesFromConseq(cell, consequences, supports, bigRuleList, limit)
            else:
                filterRules(cell, consequences, supports, bigRuleList, limit)
    return bigRuleList

接受频繁集列表及其支持度作为参数, 遍历各频繁集根据给定的可信度范围寻找关联规则.

编写test方法进行测试:

def test():
    dataSet = [[1, 3, 4], [2, 3, 5], [1, 2, 3, 5], [2, 5]]
    cells, supports = apriori(dataSet, 0.5)
    # print(cells)
    rules = generateRules(cells, supports)
    print(rules)
    # units = createUnit(dataSet)
    # print(units)
    # cells, supports = filterCandidates(dataSet, units, 0.5)
    # print(cells, supports)
    # cells = createKCell(selected, 2)
    # print(cells)

顺便展示一下各函数的用法, 完整代码可以看这里

Apriori算法进行关联分析的更多相关文章

  1. 机器学习实战 - 读书笔记(11) - 使用Apriori算法进行关联分析

    前言 最近在看Peter Harrington写的"机器学习实战",这是我的学习心得,这次是第11章 - 使用Apriori算法进行关联分析. 基本概念 关联分析(associat ...

  2. 【机器学习实战】第11章 使用 Apriori 算法进行关联分析

    第 11 章 使用 Apriori 算法进行关联分析 关联分析 关联分析是一种在大规模数据集中寻找有趣关系的任务. 这些关系可以有两种形式: 频繁项集(frequent item sets): 经常出 ...

  3. 机器学习实战(Machine Learning in Action)学习笔记————07.使用Apriori算法进行关联分析

    机器学习实战(Machine Learning in Action)学习笔记————07.使用Apriori算法进行关联分析 关键字:Apriori.关联规则挖掘.频繁项集作者:米仓山下时间:2018 ...

  4. 机器学习——使用Apriori算法进行关联分析

    从大规模的数据集中寻找隐含关系被称作为关联分析(association analysis)或者关联规则学习(association rule learning). Apriori算法 优点:易编码实现 ...

  5. 使用Apriori算法进行关联分析

    关联分析是一种在大规模数据集中寻找有趣关系的任务.这些关系可以有两种形式:频繁项集或者关联规则.频繁项集是指经常出现在一块的物品的集合,关联规则暗示两种物品之间可能存在很强的关系.一个项集的支持度被定 ...

  6. 第十一章:使用Apriori算法进行关联分析

  7. 使用Apriori算法和FP-growth算法进行关联分析

    系列文章:<机器学习实战>学习笔记 最近看了<机器学习实战>中的第11章(使用Apriori算法进行关联分析)和第12章(使用FP-growth算法来高效发现频繁项集).正如章 ...

  8. 数据挖掘算法:关联分析二(Apriori)

    二.Apriori算法 上文说到,大多数关联规则挖掘算法通常采用的策略是分解为两步: 频繁项集产生,其目标是发现满足具有最小支持度阈值的所有项集,称为频繁项集(frequent itemset). 规 ...

  9. 数据挖掘算法:关联分析二(FP-tree算法)

    三.FP-tree算法 下面介绍一种使用了与Apriori完全不同的方法来发现频繁项集的算法FP-tree.FP-tree算法在过程中没有像Apriori一样产生候选集,而是采用了更为紧凑的数据结构组 ...

随机推荐

  1. poj3924

    题目:给定一个起点(xw1, yw1),直线经过(xw2, yw2),速度为vw无限运动的点,还有一个起点(xt1, yt1),终点(xt2, yt2),并且在以vt速度在两者往返运动,求两者在运动中 ...

  2. Class AB与Class D功放

    D类功放   又称之为数字功放,其特点是,工作效率高,体积小. D类功放的结构       第一部分为调制器,最简单的只需用一只运放构成比较器即可完成.把原始音频信号加上一定直流偏置后放在运放的正输入 ...

  3. CefSharp访问需要认证网页或接口(在Request的Headers中添加认证Token)

    public class MyRequestHandler : DefaultRequestHandler { public static readonly string VersionNumberS ...

  4. AJPFX外汇的常见形态

    AJPFX:外汇价常见形态 外汇的价格,本质上是由供求关系决定的,但是在技术分析的世界里,是什么原因导致供求关系的改变并不重要,也没有人能准确的找出所有的因素并加以判断,但是供求关系被改变后的外汇走势 ...

  5. AJPFX讲解外汇保证金交易的货币符号和外汇的报价方式

    AJPFX:外汇保证金交易的货币符号 认识货币名字是必须的入门基础,通过货币符号,首先要知道买卖哪个货币,下面是一些货币的符号.买卖外汇就是这些任意其中某两种货币的比值,也就是汇率.根据汇率比的升高或 ...

  6. c setjmp longjmp

    http://coolshell.cn/?s=setjmp http://www.cnblogs.com/hazir/p/c_setjmp_longjmp.html double divide(dou ...

  7. Android逆向进阶—— 脱壳的奥义(基ART模式下的dump)

    本文作者:i春秋作家HAI_ZHU 0×00 前言 市面上的资料大多都是基于Dalvik模式的dump,所以这此准备搞一个ART模式下的dump.HAI_的使用手册(各种好东西) Dalvik模式是A ...

  8. Linux学习笔记-基本操作4

    1. gdb调试2. makefile的编写3. 系统IO函数 1. gdb调试:        1. 启动gdb + 可执行文件        2. 查看代码:                l== ...

  9. 解决linux下source /etc/profile关闭终端失效问题

    本来想配置环境变量的,看网上和博客上很多说改/etc/profile,然后source /etc/profile之后就可以永久保存使环境变量生效,但是终端一关闭,就环境变量就失效了,其他终端也用不了. ...

  10. 初印象至Vue路由

    初印象系列为快速了解一门技术的内容,后续会推出本人应用这门技术时发现的一些认识. Vue路由和传统路由的区别: Vue路由主要是用来实现单页面应用内各个组件之间的切换,同样支持传递参数等功能.而传统路 ...