Apriori算法(C#)
AprioriMethod.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web; /// <summary>
///AprioriMethod 的摘要说明
/// </summary>
public class AprioriMethod
{ private readonly static int support = ; // 支持度阈值
private readonly static double confidence = 0.7; // 置信度阈值
private readonly static char[] item_Split = { ';' }; // 项之间的分隔符
private readonly static string itemSplit = ";";
private readonly static String CON = "->"; // 项之间的分隔符 private readonly static List<String> transList = new List<String>(); //所有交易 public AprioriMethod()
{
//
//TODO: 在此处添加构造函数逻辑
//
//初始化交易记录
transList.Add("移动硬盘;电脑;手机;优盘");
transList.Add("电脑;优盘;");
transList.Add("电脑;优盘;");
transList.Add("手机;电脑;移动硬盘;");
transList.Add("移动硬盘;手机;");
transList.Add("电脑;手机;");
transList.Add("移动硬盘;手机;");
transList.Add("移动硬盘;电脑;手机;优盘;");
transList.Add("移动硬盘;电脑;手机;"); } public Dictionary<String, int> getFC() //计算所有频繁项集
{
Dictionary<String, int> frequentCollections = new Dictionary<String, int>();//所有的频繁集
foreach (KeyValuePair<string, int> item in getItem1FC())
{
if (frequentCollections.ContainsKey(item.Key))
{
frequentCollections.Remove(item.Key);
}
frequentCollections.Add(item.Key, item.Value);
}
Dictionary<String, int> itemkFcMap = new Dictionary<String, int>();
foreach (KeyValuePair<string, int> item in getItem1FC())
{
itemkFcMap.Add(item.Key, item.Value);
} while (itemkFcMap != null && itemkFcMap.Count != )
{
Dictionary<String, int> candidateCollection = getCandidateCollection(itemkFcMap);
List<String> ccKeySet = candidateCollection.Keys.ToList(); //对候选集项进行累加计数
foreach (String trans in transList)
{
foreach (String candidate in ccKeySet)
{
bool flag = true; // 用来判断交易中是否出现该候选项,如果出现,计数加1
String[] candidateItems = candidate.Split(item_Split, StringSplitOptions.RemoveEmptyEntries);
foreach (String candidateItem in candidateItems)
{
if (trans.IndexOf(candidateItem + itemSplit) == -)
{
flag = false;
break;
}
}
if (flag)
{
int count = candidateCollection[candidate];
candidateCollection.Remove(candidate);
candidateCollection.Add(candidate, count + );
}
}
} //从候选集中找到符合支持度的频繁集项
itemkFcMap.Clear();
foreach (String candidate in ccKeySet)
{
int count = candidateCollection[candidate];
if (count >= support)
{
itemkFcMap.Add(candidate, count);
}
} //合并所有频繁集
foreach (KeyValuePair<string, int> item in itemkFcMap)
{
if (frequentCollections.ContainsKey(item.Key))
{
frequentCollections.Remove(item.Key);
}
frequentCollections.Add(item.Key, item.Value);
}
}
return frequentCollections;
} private Dictionary<String, int> getItem1FC() //计算所有频繁1项集
{
Dictionary<String, int> sItem1Fc = new Dictionary<String, int>();
Dictionary<String, int> rItem1Fc = new Dictionary<String, int>(); //频繁1项集
foreach (String trans in transList)
{
String[] items = trans.Split(item_Split, StringSplitOptions.RemoveEmptyEntries);
foreach (String item in items)
{
int count;
if (sItem1Fc.ContainsKey(item + itemSplit))
{
count = sItem1Fc[item + itemSplit];
sItem1Fc.Remove(item + itemSplit);
sItem1Fc.Add(item + itemSplit, count + );
}
else
{
sItem1Fc.Add(item + itemSplit, );
}
}
}
List<String> keySet = sItem1Fc.Keys.ToList();
foreach (String key in keySet)
{
int count = sItem1Fc[key];
if (count >= support)
{
rItem1Fc.Add(key, count);
}
}
return rItem1Fc;
} private Dictionary<String, int> getCandidateCollection(Dictionary<String, int> itemkFcMap) //生成候选项集
{
Dictionary<String, int> candidateCollection = new Dictionary<String, int>();
List<String> itemkSet1 = itemkFcMap.Keys.ToList();
List<String> itemkSet2 = itemkFcMap.Keys.ToList();
foreach (String itemk1 in itemkSet1)
{
foreach (String itemk2 in itemkSet2)
{
//进行连接
String[] tmp1 = itemk1.Split(item_Split, StringSplitOptions.RemoveEmptyEntries);
String[] tmp2 = itemk2.Split(item_Split, StringSplitOptions.RemoveEmptyEntries); String c = "";
if (tmp1.Length == )
{
if (tmp1[].CompareTo(tmp2[]) < )
{
c = tmp1[] + itemSplit + tmp2[] + itemSplit;
}
}
else
{
bool flag = true;
for (int i = ; i < tmp1.Length - ; i++)
{
if (!tmp1[i].Equals(tmp2[i]))
{
flag = false;
break;
}
}
if (flag && (tmp1[tmp1.Length - ].CompareTo(tmp2[tmp2.Length - ]) < ))
{
c = itemk1 + tmp2[tmp2.Length - ] + itemSplit;
}
} //进行剪枝
bool hasInfrequentSubSet = false;
if (!c.Equals(""))
{
String[] tmpC = c.Split(item_Split, StringSplitOptions.RemoveEmptyEntries);
for (int i = ; i < tmpC.Length; i++)
{
String subC = "";
for (int j = ; j < tmpC.Length; j++)
{
if (i != j)
{
subC = subC + tmpC[j] + itemSplit;
}
}
if (!itemkFcMap.ContainsKey(subC))
{
hasInfrequentSubSet = true;
break;
}
}
}
else
{
hasInfrequentSubSet = true;
} if (!hasInfrequentSubSet)
{
candidateCollection.Add(c, );
}
}
}
return candidateCollection;
} public Dictionary<String, Double> getRelationRules(Dictionary<String, int> frequentCollection) //计算关联规则
{
Dictionary<String, Double> relationRules = new Dictionary<String, Double>();
List<String> keySet = frequentCollection.Keys.ToList();
foreach (String key in keySet)
{
double countAll = frequentCollection[key];
String[] keyItems = key.Split(item_Split, StringSplitOptions.RemoveEmptyEntries);
if (keyItems.Length > )
{
List<String> source = keyItems.ToList(); //Collections.addAll(source, keyItems);
List<List<String>> result = new List<List<String>>();
buildSubSet(source, result); //获得source的所有非空子集
foreach (List<String> itemList in result)
{
if (itemList.Count < source.Count)
{ //只处理真子集
List<String> otherList = new List<String>();
foreach (String sourceItem in source)
{
if (!itemList.Contains(sourceItem))
{
otherList.Add(sourceItem);
}
}
String reasonStr = "";//前置
String resultStr = "";//结果
foreach (String item in itemList)
{
reasonStr = reasonStr + item + itemSplit;
}
foreach (String item in otherList)
{
resultStr = resultStr + item + itemSplit;
}
double countReason = frequentCollection[reasonStr];
double itemConfidence = countAll / countReason;//计算置信度
if (itemConfidence >= confidence)
{
String rule = reasonStr + CON + resultStr;
//relationRules.Remove(rule);
relationRules.Add(rule, itemConfidence);
}
}
}
}
}
return relationRules;
} private void buildSubSet(List<String> sourceSet, List<List<String>> result) //建立频繁项集的子集
{
// 仅有一个元素时,递归终止。此时非空子集仅为其自身,所以直接添加到result中
if (sourceSet.Count == )
{
List<String> set = new List<String>();
set.Add(sourceSet[]);
result.Add(set);
}
else if (sourceSet.Count > )
{
// 当有n个元素时,递归求出前n-1个子集,在于result中
buildSubSet(sourceSet.Take(sourceSet.Count - ).ToList(), result);
int size = result.Count;// 求出此时result的长度,用于后面的追加第n个元素时计数
// 把第n个元素加入到集合中
List<String> single = new List<String>();
single.Add(sourceSet[sourceSet.Count - ]);
result.Add(single);
// 在保留前面的n-1子集的情况下,把第n个元素分别加到前n个子集中,并把新的集加入到result中;
// 为保留原有n-1的子集,所以需要先对其进行复制
List<String> clone;
for (int i = ; i < size; i++)
{
clone = new List<String>();
foreach (String str in result[i])
{
clone.Add(str);
}
clone.Add(sourceSet[sourceSet.Count - ]);
result.Add(clone);
}
}
} }
Default.aspx.cs
AprioriMethod apriori = new AprioriMethod();
Dictionary<String, int> frequentCollection = apriori.getFC();
Response.Write("----------------频繁集" + "----------------");
Response.Write("<br/>");
foreach (var item in frequentCollection)
{
Response.Write(item.Key + "-----" + item.Value);
Response.Write("<br/>");
} Dictionary<String, Double> relationRules = apriori.getRelationRules(frequentCollection);
Response.Write("----------------关联规则" + "----------------");
Response.Write("<br/>");
foreach (var item in relationRules)
{
Response.Write(item.Key + "-----" + item.Value);
Response.Write("<br/>");
}
结果:
----------------频繁集----------------
移动硬盘;-----6
电脑;-----7
手机;-----7
优盘;-----4
电脑;移动硬盘;-----4
电脑;手机;-----5
电脑;优盘;-----3
手机;移动硬盘;-----6
电脑;手机;移动硬盘;-----4
----------------关联规则----------------
电脑;->手机;-----0.714285714285714
手机;->电脑;-----0.714285714285714
优盘;->电脑;-----0.75
手机;->移动硬盘;-----0.857142857142857
移动硬盘;->手机;-----1
电脑;手机;->移动硬盘;-----0.8
电脑;移动硬盘;->手机;-----1
Apriori算法(C#)的更多相关文章
- Apriori算法的原理与python 实现。
前言:这是一个老故事, 但每次看总是能从中想到点什么.在一家超市里,有一个有趣的现象:尿布和啤酒赫然摆在一起出售.但是这个奇怪的举措却使尿布和啤酒的销量双双增加了.这不是一个笑话,而是发生在美国沃尔玛 ...
- #研发解决方案#基于Apriori算法的Nginx+Lua+ELK异常流量拦截方案
郑昀 基于杨海波的设计文档 创建于2015/8/13 最后更新于2015/8/25 关键词:异常流量.rate limiting.Nginx.Apriori.频繁项集.先验算法.Lua.ELK 本文档 ...
- 数据挖掘算法(四)Apriori算法
参考文献: 关联分析之Apriori算法
- 机器学习实战 - 读书笔记(11) - 使用Apriori算法进行关联分析
前言 最近在看Peter Harrington写的"机器学习实战",这是我的学习心得,这次是第11章 - 使用Apriori算法进行关联分析. 基本概念 关联分析(associat ...
- 关联规则挖掘之apriori算法
前言: 众所周知,关联规则挖掘是数据挖掘中重要的一部分,如著名的啤酒和尿布的问题.今天要学习的是经典的关联规则挖掘算法--Apriori算法 一.算法的基本原理 由k项频繁集去导出k+1项频繁集. 二 ...
- 利用Apriori算法对交通路况的研究
首先简单描述一下Apriori算法:Apriori算法分为频繁项集的产生和规则的产生. Apriori算法频繁项集的产生: 令ck为候选k-项集的集合,而Fk为频繁k-项集的集合. 1.首先通过单遍扫 ...
- Apriori算法例子
1 Apriori介绍 Apriori算法使用频繁项集的先验知识,使用一种称作逐层搜索的迭代方法,k项集用于探索(k+1)项集.首先,通过扫描事务(交易)记录,找出所有的频繁1项集,该集合记做L1,然 ...
- Apriori算法实例----Weka,R, Using Weka in my javacode
学习数据挖掘工具中,下面使用4种工具来对同一个数据集进行研究. 数据描述:下面这些数据是15个同学选修课程情况,在课程大纲中共有10门课程供学生选择,下面给出具体的选课情况,以ARFF数据文件保存,名 ...
- Apriori算法在购物篮分析中的运用
购物篮分析是一个很经典的数据挖掘案例,运用到了Apriori算法.下面从网上下载的一超市某月份的数据库,利用Apriori算法进行管理分析.例子使用Python+MongoDB 处理过程1 数据建模( ...
- 关于apriori算法的一个简单的例子
apriori算法是关联规则挖掘中很基础也很经典的一个算法,我认为很多教程出现大堆的公式不是很适合一个初学者理解.因此,本文列举一个简单的例子来演示下apriori算法的整个步骤. 下面这个表格是代表 ...
随机推荐
- 【2017-02-24】循环嵌套、跳转语句、异常语句、迭代穷举、while
一.循环嵌套 1.格式 for() { for() { } } 2.执行顺序 先执行外边循环进到循环体发现里面的循环,开始执行里面的循环.等到里面的循环执行完毕,再执行外边的循环. 在外面循环第一次, ...
- Java Web(十三) 使用javamail进行发送邮件,(使用QQ,163,新浪邮箱服务器)
加油加油. --WH 一.发送邮件的原理 在了解其原理之前,先要知道两个协议,SMTP和POP3 SMTP:Simple Mail Transfer Protocol,即简单邮件传输协议,发送邮件的协 ...
- HTTP 返回状态代码详解
1xx(临时响应)表示临时响应并需要请求者继续执行操作的状态代码. 100(继续)请求者应当继续提出请求. 服务器返回此代码表示已收到请求的第一部分,正在等待其余部分:101(切换协议)请求者已要求服 ...
- 轻松理解JavaScript之AJAX
摘要 AJAX技术是网页构建的必备技能之一,本文希望能帮助大家轻松的学习这项技术 一.什么是ajax? ajax(异步javascript xml) 能够刷新局部网页数据而不是重新加载整个网页. 二. ...
- 2017 Android 面试题 [ 基础与细节 ]
2017 Android 面试题 [ 基础与细节 ] 感谢@chuyao抛出的这些问题,平时业务代码写多了,很多基础的东西变得含糊不清了,这次裸辞出来找工作确实没有之前顺利,顺便求上海Android开 ...
- 【微信公众平台SDK(链式调用)】经过半个月的迭代,今天抽空写了个Demo
这个项目是在实际开发中逐渐完善的,开发过程基于ASP.Net Core 1.1,实际生成会兼容Net4.5. 写有完善的代码提示,怎么用就不多做解释了,引用好实例中的命名空间基本上就可以通过智能提示了 ...
- 用Visual Studio Code Debug世界上最好的语言
前言 这阵子因缘巧合接手了一个辣鸡项目,是用世界上最好的拍黄片写的,项目基本是另一个小伙伴在撸码,我就兼职打杂和发布做点运维的工作. 然后昨天项目上了测试版之后,一用起来Error满天飞了.让小伙伴查 ...
- 一场完美的“秒杀”:API加速的业务逻辑
清晨,我被一个客户电话惊醒,客户异常焦急,寻问CDN能不能帮助他们解决“秒杀”的问题,他们昨天刚刚进行了“整点秒杀活动”,结果并发量过大,导致服务宕机,用户投诉. 为了理清思路,我问了对方三个问题: ...
- 英伟达CUVID硬解,并通过FFmpeg读取文件
虽然FFmpeg本身有cuvid硬解,但是找不到什么好的资料,英伟达的SDK比较容易懂,参考FFmpeg源码,将NVIDIA VIDEO CODEC SDK的数据获取改为FFmpeg获取,弥补原生SD ...
- WebService客户端添加SOAPHeader信息
通过JAXBContext创建Marshaller对头信息进行解析为dom,获取WSBindingProvider,使用Headers.creat()创建soap的Header元素: 另外就是:将us ...