第二次数据挖掘实验报告
合集下载
相关主题
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
六、教师Baidu Nhomakorabea语
1、完成所有规定的实验内容，实验步骤正确，结果正确；
2、完成绝大部分规定的实验内容，实验步骤正确，结果正确；
3、完成大部分规定的实验内容，实验步骤正确，结果正确；
4、基本完成规定的实验内容，实验步骤基本正确，所完成的结果基本正确；
5、未能很好地完成规定的实验内容或实验步骤不正确或结果不正确。
五、实验总结（包括心得体会、问题回答及实验改进意见，可附页）
通过本次实验，我大致明白了Apriori算法，Aprori算法利可以很好的找出关联关系，但是每一次求候选集都需要扫描一次所有数据记录，那么在面临千万级别的数据记录就显得有点无力了。
因此FpGrowth算法出现了，它是通过构造一个树结构来压缩数据记录，使得挖掘频繁项集只需要扫描两次数据记录，且该算法不需要生成候选集合，所以效率会比较高。
# 导入数据集，根据自己的目录来插入
inputfile = 'D:\数据挖掘\menu_orders.xls'
#导出结果
outputfile = 'D:\数据挖掘\apriori_rules.xls'
# 读取数据
data = pd.read_excel(inputfile, header=None)
for i in column2:
cofidence_series[ms.join(i)] = support_series[ms.join(sorted(i))] / support_series[ms.join(i[:len(i) - 1])]
# 置信度筛选
for i in cofidence_series[cofidence_series > confidence].index:
# 初步根据支持度筛选
column = list(support_series[support_series > support].index)
k = 0
while len(column) > 1:
k = k + 1
print(u'\n正在进行第%s次搜索...' % k)
column = connect_string(column, ms)
c—e--a
0.3
1.000000
a—e--c
0.3
1.000000
c--a
0.5
0.714286
a--c
0.5
0.714286
a--b
0.5
0.714286
c--b
0.5
0.714286
b--a
0.5
0.625000
b--c
0.5
0.625000
a—c--e
0.3
0.600000
b—c--a
0.3
print(u'\n转换原始数据至0-1矩阵....')
# 转换0-1矩阵的过渡函数
ct = lambda x : pd.Series(1, index=x[pd.notnull(x)])
# 用map方式执行转换
b = map(ct, data.as_matrix())
# 实现矩阵转换，没有值的用0填充
顾客
菜品1
菜品2
菜品3
菜品4
1
a
c
e
2
b
d
3
b
c
4
a
b
c
d
5
a
b
6
b
c
7
a
b
8
a
b
c
e
9
a
b
c
10
a
c
e
四、实验结果（包括程序或图表、结论陈述、数据记录及分析等，可附页）
1.找最大K项频繁集
C1候选项集每个事务计算后的支持度
{a}
0.7
{b}
0.8
{c}
0.7
{d}
0.2
{e}
0.3
根据最小支持度选出的1项频繁项集L1
# j的范围是i~列表x的长度
for j in range(i, len(x)):
# 判断等式是否成立
if x[i][:l - 1] == x[j][:l - 1] and x[i][l - 1] != x[j][l - 1]:
# 对列表r中追加排好序的元素
r.append(x[i][:l - 1] + sorted([x[j][l - 1], x[i][l - 1]]))
return r
# 寻找关联规则的函数
def find_rule(d, support, confidence, ms=u'--'):
# 定义输出结果
result = pd.DataFrame(index=['support', 'confidence'])
# 支持度序列
support_series = 1.0 * d.sum() / len(d)
{a,c}
0.5
{a,e}
0.3
{b,c}
0.5
{b,d}
0.2
{c,e}
0.3
由L1与L2连接得到候选集C3
{a,b,c}
0.3
{a,c,e}
0.3
根据最小支持度得出的频繁项集L3
{a,b,c}
0.3
{a,c,e}
0.3
2有频繁集产生关联规则
e--a
0.3
1.000000
e--c
0.3
1.000000
#进行排序后的ms和x放到一个列表里赋值给x
x = list(map(lambda i: sorted(i.split(ms)), x))
#把x列表的第一个元素长度赋值给l
l = len(x[0])
#创建一个空字典r
r = []
#i的范围是0~列表x的长度
for i in range(len(x)):
result[i] = 0.0
result[i]['confidence'] = cofidence_series[i]
result[i]['support'] = support_series[ms.join(sorted(i.split(ms)))]
# 结果整理，输出
result = result.T.sort_values(['confidence', 'support'], ascending=False)
0.600000
a—c--b
0.3
0.600000
a—b--c
0.3
0.600000
代码：
Apriori.py
from __future__ import print_function
#引入pandas包
import pandas as pd
# 自定义连接函数，用于实现L_{k-1}到C_k的连接
def connect_string(x, ms):
for j in range(len(i)):
column2.append(i[:j] + i[j + 1:] + i[j:j + 1])
# 定义置信度序列
cofidence_series = pd.Series(index=[ms.join(i) for i in column2])
# 计算置信度序列
column = list(support_series_2[support_series_2 > support].index)
column2 = []
# 遍历可能的推理，如{A,B,C}究竟是A+B-->C还是B+C-->A还是C+A-->B？
for i in column:
i = i.split(ms)
# 计算连接后的支持度
support_series_2 = 1.0 * d_2[[ms.join(i) for i in column]].sum() / len(d)
# 新一轮支持度筛选
support_series = support_series.append(support_series_2)
一、实验目的及要求
1、掌握Apriori算法的使用。
2、理解算法流程、剪枝原理。
二、实验环境及相关情况（包含使用软件、实验设备、主要仪器及材料等）
1．使用软件：Python
2．实验设备：联网个人计算机
三、实验内容
已知10位顾客的点单菜品如下所示，请使用关联规则算法对菜品的关联性进行分析。可以尝试不同的支持度和置信度组合（例如：支持度=0.3，置信度=0.3和支持度=0.4，置信度=0.4……），对算法输出结果进行简单文字说明。
data = pd.DataFrame(list(b)).fillna(0)
print(u'\n转换完毕')
del b # 删除中间变量b，节省内存
support = 0.2 # 最小支持度
confidence = 0.5 # 最小置信度
# 连接符，用来区分不同元素
ms = '---'
# 保存结果
find_rule(data,support,confidence, ms).to_excel(outputfile)
{a}
0.7
{b}
0.8
{c}
0.7
{d}
0.2
{e}
0.3
由L1得到的候选项集C2并计算支持度
{a,b}
0.5
{a,c}
0.5
{a,d}
0.1
{a,e}
0.3
{b,c}
0.5
{b,d}
0.2
{b,d}
0.1
{c,d}
0.1
{c,e}
0.3
{d,e}
0
根据最小支持度选出的频繁项集L2
{a,b}
0.5
print(u'\n结果为：')
print(result)
return result
cal_apriori.py
from __future__ import print_function
import pandas as pd
# 导入自己编写的apriori算法
from apriori import *
print(u'数目：%s...' % len(column))
# 新一批支持度的计算函数
sf = lambda i: d[i].prod(axis=1, numeric_only=True)
# 创建连接数据，这一步耗时、耗内存最严重。当数据集较大时，可以考虑并行运算优化。
d_2 = pd.DataFrame(list(map(sf, column)), index=[ms.join(i) for i in column]).T
评定等级：
签名：
1、完成所有规定的实验内容，实验步骤正确，结果正确；
2、完成绝大部分规定的实验内容，实验步骤正确，结果正确；
3、完成大部分规定的实验内容，实验步骤正确，结果正确；
4、基本完成规定的实验内容，实验步骤基本正确，所完成的结果基本正确；
5、未能很好地完成规定的实验内容或实验步骤不正确或结果不正确。
五、实验总结（包括心得体会、问题回答及实验改进意见，可附页）
通过本次实验，我大致明白了Apriori算法，Aprori算法利可以很好的找出关联关系，但是每一次求候选集都需要扫描一次所有数据记录，那么在面临千万级别的数据记录就显得有点无力了。
因此FpGrowth算法出现了，它是通过构造一个树结构来压缩数据记录，使得挖掘频繁项集只需要扫描两次数据记录，且该算法不需要生成候选集合，所以效率会比较高。
# 导入数据集，根据自己的目录来插入
inputfile = 'D:\数据挖掘\menu_orders.xls'
#导出结果
outputfile = 'D:\数据挖掘\apriori_rules.xls'
# 读取数据
data = pd.read_excel(inputfile, header=None)
for i in column2:
cofidence_series[ms.join(i)] = support_series[ms.join(sorted(i))] / support_series[ms.join(i[:len(i) - 1])]
# 置信度筛选
for i in cofidence_series[cofidence_series > confidence].index:
# 初步根据支持度筛选
column = list(support_series[support_series > support].index)
k = 0
while len(column) > 1:
k = k + 1
print(u'\n正在进行第%s次搜索...' % k)
column = connect_string(column, ms)
c—e--a
0.3
1.000000
a—e--c
0.3
1.000000
c--a
0.5
0.714286
a--c
0.5
0.714286
a--b
0.5
0.714286
c--b
0.5
0.714286
b--a
0.5
0.625000
b--c
0.5
0.625000
a—c--e
0.3
0.600000
b—c--a
0.3
print(u'\n转换原始数据至0-1矩阵....')
# 转换0-1矩阵的过渡函数
ct = lambda x : pd.Series(1, index=x[pd.notnull(x)])
# 用map方式执行转换
b = map(ct, data.as_matrix())
# 实现矩阵转换，没有值的用0填充
顾客
菜品1
菜品2
菜品3
菜品4
1
a
c
e
2
b
d
3
b
c
4
a
b
c
d
5
a
b
6
b
c
7
a
b
8
a
b
c
e
9
a
b
c
10
a
c
e
四、实验结果（包括程序或图表、结论陈述、数据记录及分析等，可附页）
1.找最大K项频繁集
C1候选项集每个事务计算后的支持度
{a}
0.7
{b}
0.8
{c}
0.7
{d}
0.2
{e}
0.3
根据最小支持度选出的1项频繁项集L1
# j的范围是i~列表x的长度
for j in range(i, len(x)):
# 判断等式是否成立
if x[i][:l - 1] == x[j][:l - 1] and x[i][l - 1] != x[j][l - 1]:
# 对列表r中追加排好序的元素
r.append(x[i][:l - 1] + sorted([x[j][l - 1], x[i][l - 1]]))
return r
# 寻找关联规则的函数
def find_rule(d, support, confidence, ms=u'--'):
# 定义输出结果
result = pd.DataFrame(index=['support', 'confidence'])
# 支持度序列
support_series = 1.0 * d.sum() / len(d)
{a,c}
0.5
{a,e}
0.3
{b,c}
0.5
{b,d}
0.2
{c,e}
0.3
由L1与L2连接得到候选集C3
{a,b,c}
0.3
{a,c,e}
0.3
根据最小支持度得出的频繁项集L3
{a,b,c}
0.3
{a,c,e}
0.3
2有频繁集产生关联规则
e--a
0.3
1.000000
e--c
0.3
1.000000
#进行排序后的ms和x放到一个列表里赋值给x
x = list(map(lambda i: sorted(i.split(ms)), x))
#把x列表的第一个元素长度赋值给l
l = len(x[0])
#创建一个空字典r
r = []
#i的范围是0~列表x的长度
for i in range(len(x)):
result[i] = 0.0
result[i]['confidence'] = cofidence_series[i]
result[i]['support'] = support_series[ms.join(sorted(i.split(ms)))]
# 结果整理，输出
result = result.T.sort_values(['confidence', 'support'], ascending=False)
0.600000
a—c--b
0.3
0.600000
a—b--c
0.3
0.600000
代码：
Apriori.py
from __future__ import print_function
#引入pandas包
import pandas as pd
# 自定义连接函数，用于实现L_{k-1}到C_k的连接
def connect_string(x, ms):
for j in range(len(i)):
column2.append(i[:j] + i[j + 1:] + i[j:j + 1])
# 定义置信度序列
cofidence_series = pd.Series(index=[ms.join(i) for i in column2])
# 计算置信度序列
column = list(support_series_2[support_series_2 > support].index)
column2 = []
# 遍历可能的推理，如{A,B,C}究竟是A+B-->C还是B+C-->A还是C+A-->B？
for i in column:
i = i.split(ms)
# 计算连接后的支持度
support_series_2 = 1.0 * d_2[[ms.join(i) for i in column]].sum() / len(d)
# 新一轮支持度筛选
support_series = support_series.append(support_series_2)
一、实验目的及要求
1、掌握Apriori算法的使用。
2、理解算法流程、剪枝原理。
二、实验环境及相关情况（包含使用软件、实验设备、主要仪器及材料等）
1．使用软件：Python
2．实验设备：联网个人计算机
三、实验内容
已知10位顾客的点单菜品如下所示，请使用关联规则算法对菜品的关联性进行分析。可以尝试不同的支持度和置信度组合（例如：支持度=0.3，置信度=0.3和支持度=0.4，置信度=0.4……），对算法输出结果进行简单文字说明。
data = pd.DataFrame(list(b)).fillna(0)
print(u'\n转换完毕')
del b # 删除中间变量b，节省内存
support = 0.2 # 最小支持度
confidence = 0.5 # 最小置信度
# 连接符，用来区分不同元素
ms = '---'
# 保存结果
find_rule(data,support,confidence, ms).to_excel(outputfile)
{a}
0.7
{b}
0.8
{c}
0.7
{d}
0.2
{e}
0.3
由L1得到的候选项集C2并计算支持度
{a,b}
0.5
{a,c}
0.5
{a,d}
0.1
{a,e}
0.3
{b,c}
0.5
{b,d}
0.2
{b,d}
0.1
{c,d}
0.1
{c,e}
0.3
{d,e}
0
根据最小支持度选出的频繁项集L2
{a,b}
0.5
print(u'\n结果为：')
print(result)
return result
cal_apriori.py
from __future__ import print_function
import pandas as pd
# 导入自己编写的apriori算法
from apriori import *
print(u'数目：%s...' % len(column))
# 新一批支持度的计算函数
sf = lambda i: d[i].prod(axis=1, numeric_only=True)
# 创建连接数据，这一步耗时、耗内存最严重。当数据集较大时，可以考虑并行运算优化。
d_2 = pd.DataFrame(list(map(sf, column)), index=[ms.join(i) for i in column]).T
评定等级：
签名：