实验目的：在掌握关联规则算法的原理的基础上，能够应用关联规则算法解决实际问题。

实验内容：根据实验数据，采用Apriori等关联规则发现算法，给出相关关联规则。

实验要求：给出数据预处理过程、关联规则发现算法及发现关联规则，并对关联规则结果进行分析说明。

实验题目：蔬菜价格相关性分析

蔬菜的价格会受季节、天气等多方面因素的影响，但许多会出现同涨或者同跌等现象，请根据给出的蔬菜价格数据，采用关联规则发现算法，发现哪些蔬菜之间具有同涨、同跌或者涨跌不同步的现象。

数据格式如下：


一、背景知识介绍
Apriori算法这里就不详细介绍了，毕竟这篇博客的重点是记录解决实验的过程。
象征性地推荐一些链接：

Apriori算法详解之【一、相关概念和核心步骤】
数据挖掘十大算法（四）：Apriori（关联分析算法）
二、数据处理
做机器学习的实验，很大一部分或者说主要的工作，就是对数据的处理。
同时，对数据处理的方法也是多种多样的，路漫漫呀~~
这里采用了xlrd/xlwt  和 pandas 包进行数据的处理(这两种包单独使用当然可以处理好数据，这里主要是为了展现知识的丰富性)，阅读下面代码前建议应先了解这两个包的基本用法。
1、数据处理第一部分：采用xlrd/xlwt将数据变得规整
思路点播博客链接：使用Apriori实现蔬菜价格涨跌关联分析

简单了解博客链接：python使用xlrd和xlwt读写Excel文件学习笔记（解决xlwt写入日期格式错误的问题）
知识点参考链接之一：
import xlrd; #导入读取excel表格数据包（第三方模块）
import xlwt; #导入写入excel表格数据包（第三方模块）

#一、准备部分
#1、Excel表格读的部分：
excel=xlrd.open_workbook('蔬菜价格3.xls') #读入本地名为‘蔬菜价格3.xls’的Excel表格
excelsheet=excel.sheets()[0]#获取excel表格中的第一个sheet工作表

#2、Excel表格写的部分：
newexcel = xlwt.Workbook(encoding = 'utf-8') #创建一个Excel对象,编码格式采用utf-8
#创建一个表名为“蔬菜价格关联分析”的工作表，cell_overwrite_ok=True表示可覆盖之前已操作的单元格
newsheet=newexcel.add_sheet('蔬菜价格关联分析',cell_overwrite_ok=True)

#3、设置表格样式，这里主要用于设置日期的格式
datastyle = xlwt.XFStyle() # 创建一个样式对象，初始化样式
datastyle.num_format_str = 'M/D/YY' #设置日期格式

#4、表格中有的空的位置不是真的为空，这里获取一个这样的值，待会用于特判
tmp=excelsheet.cell_value(5,2)

#二、正式开始处理数据，主要思路：从旧表中读出写入新表
ri=2 #用于读原始第ri行
rj=0#用于读原始第rj列
wi=0#用于写入表格的第wi行
wj=1#用于写入表格的第wj列
#创建新表的第一行，包括日期和各个菜的菜名
newsheet.write(0,0,excelsheet.cell_value(0,0))#将旧表的（0，0）位置的日期写到新表的（0，0）位置

#1、先读取蔬菜列和禽肉类的列名，暂时先不处理禽肉类的一个K位置为空值的特殊情况
while ri<42:
    rj=1#蔬菜在第1列,有40种,肉类在第3列，有23种
    newsheet.write(0,wj,excelsheet.cell_value(ri,rj))
    newsheet.write(0,wj+40,excelsheet.cell_value(ri,rj+2))
    ri=ri+1
    wj=wj+1

#2、先整理蔬菜的价格
ri=42 #遍历原始第ri行
rj=2#遍历原始第rj列
wi=0#写入表格的第wi行
wj=1#写入表格的第wj行
while ri<22320:
    if ri%47>=42:
        ri=ri+6
        wi=wi+1
        newsheet.write(wi,0,excelsheet.cell_value(ri,0),datastyle)
    else:
        if excelsheet.cell_value(ri,rj)!=tmp:
            newsheet.write(wi,wj,excelsheet.cell_value(ri,rj))              
        wj=wj%40+1
    ri=ri+1

#3、再整理禽肉类的价格
ri=26 #遍历原始第ri行
rj=4#遍历原始第4列
wi=0#写入表格的第wi行
wj=41#写入表格的第wj行，从第41列开始
while ri<22320:
    if ri%47>=26:
        ri=ri+22
        wi=wi+1
        wj=41
    else:
        if excelsheet.cell_value(ri,rj)!=tmp:      
            newsheet.write(wi,wj,excelsheet.cell_value(ri,rj))              
        wj=wj%(41+24)+1
    ri=ri+1
  
newexcel.save('蔬菜数据处理过渡版.xls')#生成处理后的表格

处理后数据示意图：



(小提示：要是看到部分日期显示为“XXXX”，把单元格拉宽就好了)
2、数据处理第二部分：采用pandas相关函数将表格变得更好操作：
import pandas as pd

#header = None用于不让蔬菜名那一行作为“表头”，便于之后步骤的数据获取
data=pd.read_excel('蔬菜数据处理过渡版.xls',header = None)

#删除第60列空值列，axis=1表示纵向，inplace=True表示删除操作对原数据生效
data.drop(labels=[60],axis=1,inplace=True)

ri=1
while ri<data.shape[0]-1:
    rj=1
    while rj<data.shape[1]:
        if (len(str(data.values[ri,rj]))==0 or len(str(data.values[ri+1,rj]))==0):
            data.iloc[ri,rj]=0
        else:
            d=float(data.values[ri,rj])-float(data.values[ri+1,rj]) #上-下 今天-昨天  正为涨，负为跌
            if d>0:
                data.iloc[ri,rj]='up'
            elif d<0:
                data.iloc[ri,rj]='down'
            else:
                data.iloc[ri,rj]=0
        rj=rj+1
    ri=ri+1

data.drop(labels=[data.shape[0]-1],axis=0,inplace=True)#删除最后一行
   
data.to_excel("蔬菜数据处理完成版.xlsx")

处理后数据示意图：


三、采用Apriori算法对蔬菜价格数据进行关联分析
1、完整代码

代码参考于：数据挖掘十大算法（四）：Apriori（关联分析算法）
我自己简略分析代码的过程：【机器学习】Apriori（关联分析算法）经典代码理解与学习笔记(Python)
import pandas as pd

#获取数据
def vegetable():
    excel=pd.read_excel('蔬菜数据处理完成版.xlsx',header = None)
    data=[]
    ri=2 #结合表格，确定需要获取数据的位置
    while ri<excel.shape[0]:
        rj=1
        temp=[]
        while rj<excel.shape[1]:
            if excel.values[ri,rj]=='up':
                temp.append(excel.values[1,rj]+'up')
            elif excel.values[ri,rj]=='down':
                temp.append(excel.values[1,rj]+'down')
            rj=rj+1
        data.append(temp)
        ri=ri+1
    return excel.shape[0]-2,data
 
# 将所有元素转换为frozenset型字典，存放到列表中
def createC1(dataSet):
    C1 = []
    for transaction in dataSet:
        for item in transaction:
            if not [item] in C1:
                C1.append([item])
    C1.sort()
    # 使用frozenset是为了后面可以将这些值作为字典的键
    return list(map(frozenset, C1))  # frozenset一种不可变的集合，set可变集合
 
# 过滤掉不符合支持度的集合
# 返回 频繁项集列表retList 所有元素的支持度字典
def scanD(D, Ck, minSupport):
    ssCnt = {}
    for tid in D:
        for can in Ck:
            if can.issubset(tid):   # 判断can是否是tid的《子集》 （这里使用子集的方式来判断两者的关系）
                if can not in ssCnt:    # 统计该值在整个记录中满足子集的次数（以字典的形式记录，frozenset为键）
                    ssCnt[can] = 1
                else:
                    ssCnt[can] += 1
    numItems = float(len(D))
    retList = []        # 重新记录满足条件的数据值（即支持度大于阈值的数据）
    supportData = {}    # 每个数据值的支持度
    for key in ssCnt:
        support = ssCnt[key] / numItems
        if support >= minSupport:
            retList.insert(0, key)
        supportData[key] = support 
    return retList, supportData # 排除不符合支持度元素后的元素 每个元素支持度
 
# 生成所有可以组合的集合
# 频繁项集列表Lk 项集元素个数k  [frozenset({2, 3}), frozenset({3, 5})] -> [frozenset({2, 3, 5})]
def aprioriGen(Lk, k):
    retList = []
    lenLk = len(Lk)
    for i in range(lenLk): # 两层循环比较Lk中的每个元素与其它元素
        for j in range(i+1, lenLk):
            L1 = list(Lk[i])[:k-2]  # 将集合转为list后取值
            L2 = list(Lk[j])[:k-2]
            L1.sort(); L2.sort()        # 这里说明一下：该函数每次比较两个list的前k-2个元素，如果相同则求并集得到k个元素的集合
            if L1==L2:
                retList.append(Lk[i] | Lk[j]) # 求并集
    return retList  # 返回频繁项集列表Ck
 
# 封装所有步骤的函数
# 返回 所有满足大于阈值的组合 集合支持度列表
def apriori(dataSet, minSupport = 0.5):
    D = list(map(set, dataSet)) # 转换列表记录为字典 
    C1 = createC1(dataSet)      # 将每个元素转会为frozenset字典    [frozenset({1}), frozenset({2}), frozenset({3}), frozenset({4}), frozenset({5})]
    L1, supportData = scanD(D, C1, minSupport)  # 过滤数据
    L = [L1]
    k = 2
    while (len(L[k-2]) > 0):    # 若仍有满足支持度的集合则继续做关联分析
        Ck = aprioriGen(L[k-2], k)  # Ck候选频繁项集
        Lk, supK = scanD(D, Ck, minSupport) # Lk频繁项集
        supportData.update(supK)    # 更新字典（把新出现的集合:支持度加入到supportData中）
        L.append(Lk)
        k += 1  # 每次新组合的元素都只增加了一个，所以k也+1（k表示元素个数）
    return L, supportData


# 获取关联规则的封装函数
def generateRules(L, supportData, minConf=0.7):  # supportData 是一个字典
    bigRuleList = []
    for i in range(1, len(L)):  # 从为2个元素的集合开始
        for freqSet in L[i]:
            # 只包含单个元素的集合列表
            H1 = [frozenset([item]) for item in freqSet]    # frozenset({2, 3}) 转换为 [frozenset({2}), frozenset({3})]
            # 如果集合元素大于2个，则需要处理才能获得规则
            if (i > 1):
                rulesFromConseq(freqSet, H1, supportData, bigRuleList, minConf) # 集合元素 集合拆分后的列表 。。。
            else:
                calcConf(freqSet, H1, supportData, bigRuleList, minConf)
    return bigRuleList
 
# 对规则进行评估 获得满足最小可信度的关联规则
def calcConf(freqSet, H, supportData, brl, minConf=0.7):
    prunedH = []  # 创建一个新的列表去返回
    for conseq in H:
        conf = supportData[freqSet]/supportData[freqSet-conseq]  # 计算置信度
        if conf >= minConf:
            #print(set(freqSet-conseq),'-->',set(conseq),'conf(置信度):',conf,',',set(freqSet),'的支持度supportData：',supportData[freqSet])
            print("{}——>{}的置信度为：{:.6f}，支持度为：{:.6f}".format(set(freqSet-conseq),set(conseq),conf,supportData[freqSet]))
            brl.append((freqSet-conseq, conseq, conf))
            prunedH.append(conseq)
    return prunedH
 
# 生成候选规则集合
def rulesFromConseq(freqSet, H, supportData, brl, minConf=0.7):
    m = len(H[0])
    if (len(freqSet) > (m + 1)): # 尝试进一步合并
        Hmp1 = aprioriGen(H, m+1) # 将单个集合元素两两合并
        Hmp1 = calcConf(freqSet, Hmp1, supportData, brl, minConf)
        if (len(Hmp1) > 1):    #need at least two sets to merge
            rulesFromConseq(freqSet, Hmp1, supportData, brl, minConf)
 
N,dataSet = vegetable()
#在这里控设置最小支持度
L,suppData = apriori(dataSet,minSupport=float(40)/float(N))
#在这里设置最小置信度
rules = generateRules(L,suppData,minConf=0.3)
#print("具有强关联规则的项集为：",rules)

2、结果稍微分析

①上面的代码输出结果：



②可通过设置支持度和置信度的不同，使显示结果数量不同！

例如，将要求都设置低一些：



这样就有机会看到“多推多”的情况了（部分显示结构截取）：




③值得注意的是：“up”和“down”是可以互推的



(frozenset({‘茭瓜up’}), frozenset({‘韭菜down’}), 0.22988505747126436), (frozenset({‘韭菜down’}), frozenset({‘茭瓜up’}), 0.273972602739726)
后记
事情太多，随便改改，草草写完，莫得办法。

日后再补？
历史的经验告诉我，写完一篇博客之后再去完善补充一般是小概率事件，人生每个阶段都有每个阶段该去完成的任务，学会安排时间分配时间非常重要！
时光匆匆，且惜时光吧，少年ㄟ( ▔, ▔ )ㄏ

单规则算法体系
算法体系由多个规则构成，规则之间相互独立，产出结果由规则独立判定。
这种算法体系的好处与应用范围：算法体系结构简单；方便算法改良，比如上新的算法，下线旧算法；可理解性强，所以可控性强。比如，在电商环境里，识别炒信刷单的商品或店铺就适合这样的体系。
数据说明
数据来源于某大型电商平台上的虚假交易用户的识别算法多年前的产出数据（数据已经脱敏）。
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import json
from pandas.io.json import json_normalize
from collections import Counter
import pyecharts as pe
from pyecharts import options as opts
导入数据：
r1 = pd.read_csv(r't1t1',names=['name','rule','date'],sep='t',parse_dates=[2])
r1.head()
算法体系优化思路
目的找出问题规则进行调优。虚假交易用户由于不涉及到对用户的惩罚与反馈，无法通过电话反馈率来衡量算法效率，因此一直找不到好的方法来衡量算法的效率，规则多数都是基于业务线员工经验来定的。
单规则认定率¶
单规则认定率。一般认为一个真实的虚假交易用户通常在多方面有会具备可疑特征，因此越是被多的规则认定，那么这个用户应该越可能是真实的虚假交易用户，反过来，如果一个规则产出的用户多是由它一条规则认定，那么这个规则很可能就不够好。也就是说如果此规则的单独认定率越高则越有问题。
def c1(x): # 删除列表最后的空值
    x.pop() 
    return x
z2 = r1.rule.str.split(',').apply(c1)
r1.rule = z2
r1.head()
t1 = Counter(r1.rule.apply(len).values)
keys =[]
for i in t1.keys():
    keys.append('rule'+str(i))
p0 = [i for i in zip(keys,list(t1.values()))]

def pie_base(data): #绘制饼状图
    c = (
        pe.charts.Pie()
        .add("", data)
        .set_global_opts(title_opts=opts.TitleOpts())
        .set_series_opts(label_opts=opts.LabelOpts(formatter="{b}: {c}"))
    )
    return c.render_notebook()

pie_base(p0)
超过50%用户都是单规则认定。
统计各条规则认定数量
ru = {} # 所有规则认定数量
rud = {} # 单规则认定数量
for i in r1.rule.values:
    for j in i:
        ru[j] = ru.get(j,0)+1
        if len(i)==1:
            rud[j]=rud.get(j,0)+1

rule1=[]
num1=[]
num2=[]
d1 ={}
for i in range(1,14):
    i = str(i)
    rule1.append('规则'+i)
    num1.append((ru[i]-rud[i])) # 多条规则认定的用户数量
    num2.append(rud[i])  # 单条规则认定的用户数量
    d1.update({i:round(rud[i]/ru[i],2)}) # 单规则认定率

def bar_different_series():  # 画图
    c = (
        pe.charts.Bar()
        .add_xaxis(rule1)
        .add_yaxis("多规则认定量", num1, gap="5%")
        .add_yaxis("单规则认定量", num2, gap="5%")
        .set_global_opts(
            title_opts=opts.TitleOpts(),
        )
    )
    return c.render_notebook()


bar_different_series()
10号规则认定数量最高，单规则认定率也最高，6号规则单规则认定率次高。
1号规则 和 3号规则 认定数量不低，单规则认定率低。
7号规则 和13号规则规则产出数最低。
规则产出的时序分析
dd={}
for i,j in r1.groupby('date'):
    z={}
    z1={}
    for k in j.rule.values:
        for m in k:
            z[m]=z.get(m,0)+1
            if len(k)==1:
                z1[m]=z1.get(m,0)+1
        dd.update({i:[z,z1]})

dd1 ={}
rname = d1.keys()
for i in rname:
    dd1.update({i:[[],[]]})
c=0
for i ,j in dd.items():
    for i1 in rname:
        try:
            dd1[i1][0].append(j[0][i1])
        except:
            dd1[i1][0].append(0)
        try:
            dd1[i1][1].append(j[1][i1])
        except:
            dd1[i1][1].append(0)


line = pe.charts.Line()
line.add_xaxis(date1)
for i in rname:
    line.add_yaxis(i, dd1[i][0], is_connect_nones=True)
for i in rname:
    line.add_yaxis(i+'dan', dd1[i][1], is_connect_nones=True)  
line.set_global_opts(title_opts=opts.TitleOpts(),)
line.set_series_opts(label_opts=opts.LabelOpts(is_show=False))
line.render_notebook()
对比优质规则1，2与最差规则10，规则10单规则认定数波动大
6号规则平时效果不好，但是某些时候好
某些规则随时间突然增长可能是规则调节的结果，作弊人数增多也是不能排除的因素
关联规则分析
from pymining import itemmining, assocrules, perftesting,seqmining

def c1(x):   # 对 rule 列进行处理
    x.pop()
    return x
z2 = r1.rule.str.split(',').apply(c1)

len(z2.values)
#1646975

relim_input = itemmining.get_relim_input(z2.values)
report = itemmining.relim(relim_input, min_support=2) # 统计出频繁项集
rules = assocrules.mine_assoc_rules(report, min_support=3000, min_confidence=0.5) # 频繁项集对应的规则
针对单规则集合进行分析：
ru = rules[-13:]
#由于单规则关联都在最后因此可以直接切片

#输出：
[(frozenset({'7'}), frozenset({'2'}), 8067, 0.6952512281306559),
 (frozenset({'7'}), frozenset({'10'}), 9715, 0.8372834611738343),
 (frozenset({'8'}), frozenset({'11'}), 63460, 0.6536338167435728),
 (frozenset({'12'}), frozenset({'2'}), 73038, 0.5008503168115862),
 (frozenset({'12'}), frozenset({'10'}), 82421, 0.5651932413528267),
 (frozenset({'1'}), frozenset({'6'}), 81605, 0.5175026951613926),
 (frozenset({'1'}), frozenset({'2'}), 117318, 0.7439786923711079),
 (frozenset({'1'}), frozenset({'11'}), 94456, 0.5989980341175725),
 (frozenset({'1'}), frozenset({'10'}), 83064, 0.5267550256833027),
 (frozenset({'4'}), frozenset({'10'}), 103074, 0.6079806529625151),
 (frozenset({'9'}), frozenset({'11'}), 143924, 0.607092390043489),
 (frozenset({'3'}), frozenset({'10'}), 213916, 0.7634458490067738),
 (frozenset({'2'}), frozenset({'10'}), 203395, 0.5446349196148367)]
作网络图：
nodes = []
n=0
for i in ru.items():
    nodes.append({"name":i[0],"symbolSize":ru[i[0]]/20000,"category":n})
    n=n+1

links = []
for i in rules[-13:]:
    links.append({'source':list(i[1])[0],'target':list(i[0])[0]})

def graph():
    c = (
        pe.charts.Graph()
        .add("",
             nodes,
             links,
             repulsion=1000,
        )
        .set_global_opts(
            legend_opts=opts.LegendOpts(is_show=False),
            title_opts=opts.TitleOpts(title=""),
        )
        .set_series_opts(label_opts=opts.LabelOpts(is_show=True))
    )
    return c.render_notebook()

graph()
10，11，6号规则认定量大，只能印证其他规则，本身得不到任何规则的印证
13号规则孤立，并且不和任何规则发生关系
9号规则能被11号印证
5号孤立
1号优质规则被多条规则印证
2号规则本身质量可以，又能印证其他规则

原文链接：
拓端数据科技 / Welcome to tecdat​tecdat.cn
关联规则是if / then语句，可帮助发现看似无关的数据之间的关系。关联规则的一个示例是“如果客户购买鸡蛋，那么他有80％的可能性也购买牛奶”。关联规则包含两个部分，一个前提（if）和一个后果（then）。前项是在数据中找到的一个或多个项目。结果就是与前项组合在一起的项（或项集）。
关联规则是通过分析频繁使用的“如果/然后”模式的数据并使用条件  支持  和  置信度  来确定最重要的关系来创建的。支持表示项目在数据库中出现的频率。置信度表示发现if / then语句为真的次数。使用FP-Growth运算符之类的运算符来挖掘频繁的if / then模式。“创建关联规则”运算符采用这些频繁项集并生成关联规则。
这样的信息可以用作关于诸如促销价格或产品安置的市场活动的决定的基础。除了上述来自市场篮子分析的示例外，当今在许多应用程序领域中都采用了关联规则，包括Web使用挖掘，入侵检测和生物信息学。
知乎视频​www.zhihu.com
视频
在这个短片中我们分享了如何使用RAPIDMINER创建关联规则和文本挖掘模型对评论数据进行分析 
输入项
项目集（常用项目集）该输入端口需要频繁的项目集。诸如FP-Growth运算符之类的运算符可用于提供这些频繁项集。
输出量
项目集（常用项目集）作为输入提供的项集将通过此端口传递，而不会更改为输出。这通常用于在其他运算符中重用相同的项目集，或在“结果”工作区中查看这些项目集。
规则（关联规则）关联规则通过此输出端口传递。
参数
条件此参数指定用于选择规则的条件。
置信度：规则的置信度定义为conf（X表示Y）= supp（X∪Y）/ supp（X）。阅读表达式时要小心：这里supp（X∪Y）的意思是“支持X和Y都出现的交易的发生”，而不是“支持X或Y都出现的交易的发生”。置信度范围为0到1。置信度是Pr（Y | X）的估计值，即在给定X的情况下观察Y的概率。
提升：规则的提升定义为提升（X表示Y）= supp（X∪Y）/（（supp（Y）x supp（X））或观察到的支持度与预期支持度之比（如果X和Y提升也可以定义为lift（X表示Y）= conf（X表示Y）/ supp（Y）.lift度量X和Y与独立性之间的距离。其范围在0到正无穷大之间。值接近1表示X和Y是独立的，规则并不有趣。
conv：conv对规则方向敏感，即conv（X表示Y）与conv（Y表示X）不同。conv定义为conv（X表示Y）=（1-supp（Y））/（1-conf（X表示Y））
增益：选择此选项时，使用增益theta参数计算增益。
laplace：选择此选项时，使用laplace k参数计算Laplace。
ps：选择此选项后，将使用ps标准进行规则选择。
min_confidence此参数指定规则的最小置信度范围：实数
min_criterion_value此参数指定所选条件的规则的最小值范围：实数
gain_theta该参数指定 在增益计算中使用的参数  Theta范围：实数
laplace_k此参数指定 在Laplace函数计算中使用的参数  k。范围：实数
参考文献
1.探析大数据期刊文章研究热点
2.618网购数据盘点-剁手族在关注什么
3.r语言文本挖掘tf-idf主题建模，情感分析n-gram建模研究
4.python主题建模可视化lda和t-sne交互式可视化
5.r语言文本挖掘nasa数据网络分析，tf-idf和主题建模
6.python主题lda建模和t-sne可视化
7.Python中的Apriori关联算法市场购物篮分析
8.通过Python中的Apriori算法进行关联规则挖掘
9.python爬虫进行web抓取lda主题语义数据分析

此篇的Microsoft关联规则算法就是用来挖掘关联关系的典型算法，闲言少叙，我们直接进入正题。
应用场景介绍
关联规则算法是在大量数据事例中挖掘项集之间的关联或相关联系，它典型的应用就是购物篮分析，通过关联规则分析帮助我们发现交易数据库中不同的商品（项）之间的联系，找到顾客购买行为模式，如购买某一个商品对其它商品的影响。进而通过挖掘结果应用于我们的超市货品摆放、库存安排、电子商务网站的导航安排、产品分类、根据购买模式对用户进行分类，相关产品推荐等等。
比较典型的为大家所熟知的就是：啤酒和尿布的故事
其实很多电子商务网站中在我们浏览相关产品的时候，它的旁边都会有相关产品推荐，当然这些它们可能仅仅是利用了分类的原理，将相同类型的的产品根据浏览量进而推荐给你，这也是关联规则应用的一种较简单的方式，而关联规则算法是基于大量的数据事实，通过数据层面的挖掘来告诉你某些产品项存在关联，有可能这种关联关系有可能是自身的，比如：牙刷和牙膏、筷子和碗...有些本身就没有关联是通过外界因素所形成的关系，经典的就是：啤酒和尿布，前一种关系通过常识我们有时候可以获取，但后一种关系通过经验就不易获得，而我们的关联规则算法解决的就是这部分问题。
技术准备
 （1）微软案例数据仓库（AdventureWorksDW208R2），这里我们应用到两张表：vAssocSeqLineItems 表和 vAssocSeqOrders 表，这两张表典型的“一对多”的关联关系，vAssocSeqOrders为订单表，vAssocSeqLineItems 表为订单明细表，两者通过OrderNumber关联，稍后的步骤我们会详细的分析这两张表内容
（2）VS2008、SQL Server、 Analysis Services
操作步骤
（1）我们这里还是利用上一期的解决方案，然后数据源，然后数据源视图，很简单的步骤，不明白的可以看我们前面几篇文章，然后将这两张表的主外键关联上，我们来看图：

很基础的东西，这里不做过多的解释，Orders为主表，Items为明细表，通过CustomerKey主键进行关联，下面我们浏览下这两张表里面的数据：

vAssocSeqOrders表内容很简单：订单号（逻辑主键）、客户号（客户表的外键）、地区、收入类型，别的没啥可预览的，这种表是太基础的内容，来看另外一张表：

vAssocSeqLineItems表，订单号（外键）、购买数量、购买产品，很简单的一张表
（2）新建挖掘结构
 这里我们新建这个数据的挖掘模型，很简单的下一步、下一步就行，有不明白的可以参照我以前的内容或者私信我，我们来看几个关键的步骤：

这里我们选择Microsoft关联规则算法，然后下一步：
 
这里我们标示好事例表和嵌套表，下一步我们指定定型数据

这这里面我们配置好键、和输入、输出预测列，然后起个名字：relevance

 至此，我们的Microsoft关联规则分析算法已经初步建立好了，下面一步我们来配置该算法几个关键属性值。
（3）参数配置
此种算法有两个参数比较重要，我们来看：
Support:定义规则被视为有效前必须存在的事例百分比。也就是说作为关联规则筛选的事例可能性，比如设置成10%，也就是说在只要在所有事例中所占比为10%的时候才能进行挖掘。
Probability:定义关联被视为有效前必须存在的可能性。该参数是作为结果筛选的一个预定参数，比如设置成10%，也就是说在预测结果中概率产生为10%以上的结果值才被展示。
我们将该模型的两个参数设置为：
MINIMUM_PROBABILITY = 0.2
MINIMUM_SUPPORT = 0.01

我们部署该模型，然后运行，我们来查看结果。
结果分析
部署完程序之后，我们通过“挖掘模型查看器”进行查看分析，不废话，我们直接看图：

从上面的截图中我们可以看到，Microsoft关联规则算法有三个面板来展示结果：规则、项集、依赖关系网络
下面我们分别来介绍这三个面板，第一个，规则：

上面有几个条件筛选项，第一个就是设置最小概率值，也就是上面我们新建模型设置的参数，第二个是是筛选规则，通过它我们找到相应的产品方便我们查看，还有一个重要性的参数，同样的对于下面结果中的第二列可能性列，最大行数设置显示的行数。
下面结果的表格中，第一列概率的值就是产品之前会产生关联的概率，按照概率从大到小排序，第二列为可能性，该度量规则的有用性。该值越大则意味着规则越有用，设置该规则的目的是避免只使用概率可能发生误导，比如有时候超市里举行促销活动会每个人都免费给一间物品，如果仅仅根据概率去推测，这件物品的概率将是1，但是这个规则是不准确的，因为它没有和其它商品发生任何关联，也就是说该值是无意义的，所以才出现了“重要性”列。
第三列即为我们的挖掘出来的结果项，前面为已有的产品项，‘—>’后面的即为推测的产品项，我们举个例子，比如：

经过排序可以看到，上图中的该条规则项为关联规则最强的一种组合：前面的为：山地自行车（Mountain-200）、山地自行车内胎（Mountain Tire Tube）然后关联关系最强的为：自行车轮胎(HL Mountain Tire)
嗯，有道理的很呀，有了山地自行车了，然后同样也具备山地自行车内胎，剩下的就是需要自行车轮胎了。
其它的也是同样的分析方法，这里我们就不分析了，有兴趣的可以自己分析，嘿..我看到上面的第三条：
自行车（Road-750）、水壶（Water Bottle）->自行车水壶框（Road Bottle Cage）
....自行车、水壶，肯定得买个自行车水壶框了......
这个水壶好有个性，下面我们来具体看看跟这个利器有关的商品有哪些....嘿嘿...我们来看图：

我那个去....瞅瞅...第一个结果：水壶框（Road Bottle Cage、Mountain Bottle Cage）...下面我目测了下...我可以明确的告诉你，丫的..这个名字叫Water Bottle(水壶...嘿嘿原谅我的E文能力)的利器最相关的就是水壶框（Bottle Cage）了...
超市里东西怎么摆放？ 网站上该产品的相关推荐该推荐神马？ 有一个顾客已经买了这个东西你推荐它啥懂了吧？......
下面我们来看第二个面板能告诉我们什么，我们打开“项集”面板：

这个面板也简单的很，上面有几个筛选框设置我们的最低支持数，最小的项集大小，最大行数，这个没啥说的，很简单，下面的结果集显示的为我们的数据集合中“支持”的事例集合个数、然后“大小”就是该规则下里面的项集的个数，第三列就是项集的详细了。
我去...上面我们分析的水壶（Water Bottle）竟然排在了第一行，该行中的项集明细为：山地自行车（Mountain-200）、水壶（Water Bottle）、自行车水壶框（Road Bottle Cage），第二行也有，看来这厮看来很有分析价值，我们后续接着分析，嘿嘿
我们进入第三个面板“依赖关系网络”，我们来看：

这幅图已经很熟悉了吧，前几篇文章中均有介绍，分析各种产品之间的关联关系的强弱，拖动右侧的滑动条然后进行分析
嘿嘿...我小心翼翼的拖动了这个滑动条...试图找找上面我们分析的哪款利器（Water Bottle）:

嘿嘿...找到了，上图中就标示了这玩意相关的商品，我们来看Mountain Bottle Cage、Road Bottle Cage这两个都是双向关联，然后Road-750、Cycling Cap、Hydration Pack...
其它的商品也利用这种规则进行分析，有兴趣的可以自己分析。
推测结果导出
我们到此步骤直接将该模型的分析结果进行预测，暂且不验证其准确性，直接将结果导出，来看看该算法的应用项，我们进入“挖掘模型预测”：

在下面的网格中设置我们的挖掘筛选规则，点击“源”，选择“预测函数”，选择PredictAssociation,将vAssocSeqLineItems，将其拖到网格中PredictAssociation 函数的“条件/参数”框。然后设置该参数为[Association].[v Assoc Seq Line Items],3

我们点击运行，直接来查看结果：

看，上面的Microsoft关联规则算法给我们推荐出来关联性最强的三种产品，分别为：Sport-100、Water Bottle、Patch kit...
当然有时候我需要只查看某一种商品，不关系其它的产品有什么关联关系，我们来做单独查询，我们在菜单中的“挖掘模型”，然后选择“单独查询”：

点击开单独筛选的条件框：

在“嵌套表输入”对话框中，选择“键列”窗格中的Touring Tire

我们点击运行，来查看结果：

可以看到这里我们只是筛选出了该商品的关联关系结果集，当然这里我们可以显示出该产品之间的关联的关系值，这里我们直接写语句：
点击运行，我们来看结果：

这里我们能看到，商品、支持的事例数，可能行、概率等明细值。
对于Microsoft关联规则算法还有一种更有趣的应用就是，根据现有的顾客已经买的的产品，然后利用它自己的挖掘模型进行推测，推测出这个顾客将下一个买什么产品，比如上面的例子中，如果某个顾客已经买了山地自行车、自行车内胎，那么利用该模型它会自动推测出该顾客下一步将会买自行车轮胎，这个用法其实很关键，通过该方法预测已经能推测出顾客下一步的购买意向！...
如果将该挖掘模型利用到电子商务网站...那么他们推荐的商品将更准确，同样所得到的精准销售也更到位...结果你懂的！
我们来看步骤：
我们来选择应用的事例表：

我们来选择两者的关联关系，可以右键直接编辑：

然后编辑筛选函数，直接看图：

点击查看结果：

可以看到，这个顾客编号为：18239的他将买优先买三个产品：Water Bottle、Road-750、Touring-1000，后面还列出他的概率和可能性...
嘿嘿..我们打开数据库来看看这个顾客的情况：

.....嘿嘿...这个顾客已经买了两个商品了，Road-250、Road Bottle Cage,根据上面的推算法则...这个顾客应该马上急需要买一个叫做Water Bottle的神器...用来喝水
然后，我们将这个结果保存到数据库..一段简单的代码就能搞出那些顾客急需要什么商品...
他们最可能买的商品有哪些....，剩下的工作你懂得！
结语
本篇文章到此结束了...结语就是我们后面还会继续分析其它的算法，有兴趣的童鞋可以提前关注。上面其实还有几部分需要补充，就是准确性验证和筛选条件挖掘，比如我想知道某些特定客户群体他们的购买的产品关联规则等等吧，后续文章继续分析这些问题。