Apriori算法Java实现

最新推荐文章于 2024-05-18 15:53:33 发布
最新推荐文章于 2024-05-18 15:53:33 发布
阅读量5.3k 收藏 57
点赞数 12
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cl723401/article/details/82916301
版权
  1. 关联算法的相关定义：
    1. 频繁项集：经常出现在一块的物品集合
    2. 关联规则：两种物品间可能存在很强的关系
    3. support（支持度）：一个项集的数据集中包含研究的项集记录所占的比例
    4. confidence（置信度）：针对某一条关联规则（{尿布--》啤酒}）定义，置信度={尿布，啤酒}的支持度/尿布的支持度
  2. Apriori算法原理：某个项集是频繁的，那么它的所有子集势必也是频繁的。反过来如果一个项集是非频繁项集，那么它所对应的超集就都是非频繁项集。

2.2频繁项集

Apriori是一个发现频繁项集的方法，输入参数是最小支持度和数据集。

  1. 首先生成所有单个物品的项集列表，遍历以后去掉不满足最小支持度的项集；
  2. 接下来对剩下的集合组合，生成包含两个元素的项集，去掉不满足最小支持度的项集。
  3. 重复过程直到去掉不满足最小支持度的项集。

2.3 找关联规则：

假设存在一条频繁项集，{A，B}，它们之间就可能存在一条关联规则，即可表示为“……-->……”,但是反过来不一定成立。

最小support衡量频繁项集，可信度衡量关联规则。

先生成一个可能的规则表，测试每条规则的可信度，结合可信度最小要求，得到关联规则，同寻找频繁项集类似，我们可以为每个频繁项集产生许多关联规则，这样就会有很多的关联规则产生。结合Apriori原理，如果某条规则不满足最小可信度要求，那么该规则的所有子集也就不满足最小可信度要求。

实现：

1.频繁项集：

package com.cl.apriori;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class Apriori {

	private double support;
	private double confidence;
	private final String ITEMSPLITE=";"; 
	
	public Apriori(){
		support=0.2;
		confidence=0.7;
		
	}
	public Apriori(double support, double confidence) {
		super();
		this.support = support;
		this.confidence = confidence;
	}
	
	/**
	 * 从src处读取所有数据，将一条条记录保存在list里
	 * @param src
	 * @return
	 * @throws IOException
	 */
	public List<String> readDataFile(String src) throws IOException{
		List recordList=new ArrayList<String>();
		InputStreamReader in=new InputStreamReader(new FileInputStream(src),"UTF-8");
		BufferedReader bin=new BufferedReader(in);

		String record="";
		while((record=bin.readLine())!=null){
			recordList.add(record);
		}
		return recordList;
	}
	/**
	 * 对每一条记录中出现的一个item统计其出现的次数，得到频繁项1的集合
	 * @param recordList
	 * @return
	 */
	public Map<String,Integer> oneFrequentSet(List<String> recordList){
		Map<String,Integer> freOne=new HashMap<String,Integer>();
		if(recordList!=null&&recordList.size()>0){
			for(String record:recordList){
				String items[]=record.split(ITEMSPLITE);
				for(String item:items){
					item+=ITEMSPLITE;
					if(freOne.get(item)==null){
						freOne.put(item, 1);
					}else{
						freOne.put(item, freOne.get(item)+1);
					}
				}
			}
		}
		return freOne;
	}
	
	/**
	 * 对项集的支持度检查，不满足支持度的剔除
	 * @param rawItemSets
	 * @param size
	 */
	public Map<String,Integer> getSupportedItemSets(Map<String,Integer> rawItemSets,int size){
		Map<String,Integer> supportedItemSets=new HashMap<String,Integer>();
		for(Entry<String,Integer> entry:rawItemSets.entrySet()){
			if(entry.getValue()*1.0>support*size){
				supportedItemSets.put(entry.getKey(),entry.getValue());
			}
		}
		if(supportedItemSets.size()==0){
			System.out.println("没有满足支持度="+support+"的频繁项集");
			return null;
		}
		return supportedItemSets;
	}
	
	/**
	 * 由k-1项构成的频繁项集构造k项频繁项集,组合
	 * @param frequentSets
	 * @return
	 */
	public Map<String,Integer> getNextCandidate(Map<String,Integer> frequentSets){
		Map<String,Integer> candidateFrequentSets=new HashMap<String,Integer>();
		List<String> freSets1=mapKeyToList(frequentSets);
		List<String> freSets2=mapKeyToList(frequentSets);
		//System.out.println(freSets1+"\n"+freSets2);
		for(int i=0;i<freSets1.size();i++){
			String record1=freSets1.get(i);
		//	System.out.println("record1:  "+record1);
			for(int j=i+1;j<freSets2.size();j++){
				String record2=freSets2.get(j);
			//	System.out.println("record2:  "+record2);
				String m=merge(record1,record2);
			//	System.out.println("m:  "+m);
				if(!containsFreuentSet(candidateFrequentSets,m)){
					candidateFrequentSets.put(m,0);
				};
			}
		}
		return candidateFrequentSets;
	}
	
	/**
	 * 判断频繁项集freSets里是否完全含有一个给定的项集m
	 * @param freSets
	 * @param m
	 * @return
	 */
	public boolean containsFreuentSet(List<String> freSets, String m) {
		
		boolean flag=false;
		for(String record:freSets){
			if(record.length()>=m.length()){
				String[] items=m.split(ITEMSPLITE);
				for(int i=0;i<items.length;i++){
					if(record.indexOf(items[i])==-1){
						flag=false;
						break;		
					}else{
						flag=true;
					}
				}
				if(flag==true){
					break;
				}
			}
		}
		return flag;
	}

	/**
	 * 判断频繁项集freSets里是否含有一个给定的项集m
	 * @param map
	 * @param m
	 * @return
	 */
	public boolean containsFreuentSet(Map<String,Integer> map, String m) {
		List<String> list=mapKeyToList(map);
		return containsFreuentSet(list, m);
	}
	/**
	 * 将map表示的频繁项集用List表示，便于找到下标处理
	 * @param map
	 * @return
	 */
	public List<String> mapKeyToList(Map<String, Integer> map) {
		List<String> list=new ArrayList<String>();
		if(map.size()!=0){
			Set<String> set=map.keySet();
			for(String s:set){
				list.add(s);
			}
		}
		return list;
	}
	
	/**
	 * 对两个项集record1和record2进行合并，去除其中重复的item项目
	 * @param record1
	 * @param record2
	 * @return
	 */
	public String merge(String record1, String record2) {
		String items2[]=record2.split(ITEMSPLITE);
		String record=record1;
		for(int i=0;i<=items2.length-1;i++){
			String item=items2[i];
			if(record1.indexOf(item)==-1){
				record+=item+ITEMSPLITE;
			}
		}
		return record;
	}
	
	/**
	 * 统计组合的频繁项集的支持度
	 * @param map
	 * @param data
	 */
	public void countCandidateFreqSet(Map<String, Integer> map,List<String> data){
		int times;
		for(Entry<String,Integer> entry:map.entrySet()){
			String str=entry.getKey();
			times=count(data,str);
			entry.setValue(times);
		}
		
	}
	
	/**
	 * 求初始data里项集m的出现的次数，即m的支持度
	 * @param data
	 * @param m
	 * @return
	 */
	public int count(List<String> data, String m) {	
		boolean flag;
		int count=0;
		for(String record:data){
			flag=true;
			if(record.length()>=m.length()){
				String items[]=m.split(ITEMSPLITE);
				for(int i=0;i<items.length;i++){
					if(record.indexOf(items[i])==-1){
						flag=false;
						break;
					}
				}
				if(flag==true){
					count++;
				}
			}
		}
		return count;
	}

	public Map<String,Integer> apriori(List<String> srcData) throws IOException{
		Map<String,Integer> freSets=new HashMap<String,Integer>();
		Map<String,Integer> candidateFreSets=new HashMap<String,Integer>();
		
		int len=srcData.size();
		
		Map<String,Integer> oneFreSets=oneFrequentSet(srcData);//获取项集为1的集合
		/*System.out.println("--------------------初始频繁1项项集-----------------------------");
		for(Entry<String, Integer> entry:oneFreSets.entrySet()){
			System.out.println(entry.getKey()+":"+entry.getValue());
		}*/
		
		oneFreSets=getSupportedItemSets(oneFreSets, len);//第一次进行清理不符合支持度的项集
		/*System.out.println("--------------------初始频繁1项项集支持度检查-----------------------------");
		for(Entry<String, Integer> entry:oneFreSets.entrySet()){
			System.out.println(entry.getKey()+":"+entry.getValue());
		}*/
		int i=1;
		while(oneFreSets!=null&&oneFreSets.size()>0){
			freSets=union(freSets,oneFreSets);          //合并上一次所求满足支持度的项集，会不会重复？
			
			//由k项项集找k+1项项集
		/*	System.out.println("--------------------初始频繁项集第"+i+"次合并的结果-----------------------------");
			for(Entry<String, Integer> entry:freSets.entrySet()){
				System.out.println(entry.getKey()+":"+entry.getValue());
			}*/
			i++;
			candidateFreSets=getNextCandidate(oneFreSets);
			/*System.out.println("--------------------组合的"+i+"项结果-----------------------------");
			for(Entry<String, Integer> entry:candidateFreSets.entrySet()){
				System.out.println(entry.getKey()+":"+entry.getValue());
			}*/
			//对候选组合的k+1项项集进行统计
			countCandidateFreqSet(candidateFreSets, srcData);
		/*	System.out.println("--------------------组合支持度计算结果-----------------------------");
			for(Entry<String, Integer> entry:candidateFreSets.entrySet()){
				System.out.println(entry.getKey()+":"+entry.getValue());
			}
			*/
			//筛选满足支持度的项集，赋值给oneFreSets
			oneFreSets=getSupportedItemSets(candidateFreSets, len);
			/*if(oneFreSets!=null){
				System.out.println("--------------------频繁项集（"+i+"项）支持度筛选的结果-----------------------------");
				for(Entry<String, Integer> entry:oneFreSets.entrySet()){
					System.out.println(entry.getKey()+":"+entry.getValue());
				}	
			}*/
		}
		
		return freSets;
	}

/**
	 * 对所有满足支持度的频繁项集做一次冗余清理：频繁项集的子集也是频繁项集，项集为1的频繁项集也没有意义
	 * @param freSets
	 * @param oneFreSets
	 */
	public Map<String, Integer> union(Map<String, Integer> freSets, Map<String, Integer> oneFreSets) {
		Map<String,Integer> tmp=new HashMap<String,Integer>();
		for(Entry<String, Integer> entry:freSets.entrySet()){
			tmp.put(entry.getKey(), entry.getValue());
		}
		
		for(Entry<String, Integer> entry:freSets.entrySet()){
			String str=entry.getKey();
			if(containsFreuentSet(oneFreSets, str)){
				tmp.remove(str);
			}
		}
		
		tmp.putAll(oneFreSets);
		return tmp;
		
				
	}

调用Aprior算法就可以找出频繁项集，以上程序并未结束，下面的函数用来求关联规则 

2.关联规则：

	/**
	 * 求关联规则
	 * @param freSets：频繁项集
	 * @param data：源数据
	 * @return
	 */
	public Map<String,Double> getRelation(Map<String,Integer> freSets,List<String> data){
		Map<String,Double> results=new HashMap<String,Double>();   //规则结果：（关联规则，置信度）
		List<String> freKeys=mapKeyToList(freSets);          //频繁项集
		System.out.println(freKeys);
		List<String> subSets=new ArrayList<String>();
		String front="",end="";
		for(String freRecord:freKeys){ 
			System.out.println("\n-------------------------频繁项集------------------\n"+freRecord);
			subSets=getSubSets(freRecord);  //每个频繁项集求其真子集
			System.out.println("------------------真子集-----------------\n"+subSets);
			for(int i=0;i<subSets.size();i++){
				front=subSets.get(i);
				System.out.println("前置："+front+"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
				for(int j=0;j<subSets.size();j++){
					end=subSets.get(j);
					if(!(isIntersected(front,end))){  //前置条件和后置条件不可以有交集
						double confidenceTest=getRealConfidence(data,subSets.get(i),subSets.get(j));
						System.out.println("前置--->后置："+front+"--->"+end+" : "+confidenceTest);
						if(confidenceTest>confidence){
							System.out.println("put:("+front+","+end+")");
							results.put(subSets.get(i)+"--->"+subSets.get(j),confidenceTest);
						}
						
					}
				}
			}
		}
		
		return results;
	}
	/**
	 * 对频繁项集的每一条规则 freRecordFront-->freRecordEnd,求置信度
	 * @param data
	 * @param freRecordFront
	 * @param freRecordEnd
	 * @return
	 */
	public double getRealConfidence(List<String> data, String freRecordFront, String freRecordEnd) {
		String str=freRecordFront+freRecordEnd;
		return count(data,str)*1.0/count(data, freRecordFront);
	}
	/**
	 * 
	 * 对频繁项集的真子集，根据源数据data,统计每一个子集的支持度
	 * @param subSets
	 * @param data
	 * @return
	 *//*
	public Map<String, Integer> getSubSetSupport(List<String> subSets,List<String> data) {
		Map<String, Integer> map=new HashMap<String, Integer>();
		if(subSets==null||subSets.size()==0)
			return null;
		for(int i=0;i<subSets.size();i++){
			map.put(subSets.get(i), count(data, subSets.get(i)));
		}
		return map;
	}*/
	/**
	 * 对一项频繁项集求其真子集
	 * @param str
	 * @return
	 */
	public List<String> getSubSets(String str){
		List<String> subSets=new ArrayList<String>();
		String[] items=str.split(ITEMSPLITE);
		int len=items.length;
		String item="";
		String flag="";
		for(int i=1;i<(int)Math.pow(2, len)-1;i++){
			flag="";
			item="";
			int tmp=i;
			do{
				flag+=""+tmp%2;
				tmp/=2;
			}while(tmp>0);
			
			for(int j=0;j<flag.length();j++){
				if(flag.charAt(j)=='1'){
					item+=items[j]+ITEMSPLITE;
				}
			}
			subSets.add(item);
		}
		return subSets;
	}
	/**
	 * 比较两个项目是否有交集
	 * @param front
	 * @param end
	 * @return
	 */
	public boolean isIntersected(String front, String end){
		if(front==null||front.length()==0||end==null||end.length()==0){
			return false;
		}
		String[] frontItems=front.split(ITEMSPLITE);
		String[] endItems=end.split(ITEMSPLITE);
		boolean flag=false;
		for(int i=0;i<frontItems.length;i++){
			for(int j=0;j<endItems.length;j++){
				if(frontItems[i].equals(endItems[j])){
					flag=true;
					break;
				}
			}
		}
		return flag;	
	}
}

3.测试结果：

@Test
	public void testGetRelation() throws IOException{
		Apriori apriori=new Apriori();
		List<String> srcData=apriori.readDataFile("E:/test/data.txt");
		/*源数据
		 * 记录条数：9
			1;2;5;
			2;4;
			2;3;
			1;2;4;
			1;3;
			2;3;
			1;3;
			1;2;3;5;
			1;2;3;

		 */
		Map<String,Integer> map=apriori.apriori(srcData);
		for(Entry<String, Integer> entry:map.entrySet()){
			System.out.println(entry.getKey()+":"+entry.getValue());
		}
		/*频繁项集
		 * 2;1;5;:2
		2;1;3;:2
		4;2;:2
		*/
		System.out.println("**********************************************");
		Map<String,Double> resuults=apriori.getRelation(map, srcData);
		for(Entry<String, Double> entry:resuults.entrySet()){
			System.out.println(entry.getKey()+":"+entry.getValue());
		}
		/*关联规则
		4; ---> 2;:1.0
		5; ---> 2;:1.0
		1;5; ---> 2;:1.0
		5; ---> 1;:1.0
		2;5; ---> 1;:1.0
		5; ---> 2;1;:1.0
		*/

详细测试请下载相关包

cl723401
关注
  • 12
    点赞
  • 踩
  • 57
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
apriori java_java实现Apriori算法——频繁项集的计算
weixin_39959335的博客
02-12 1164
请注意，本文编写于 1180 天前，最后修改于 692 天前，其中某些信息可能已经过时。前言之前学校开的选修课《数据挖掘》，布置的两道算法题，时间有限完成其中一道：用Apriori算法求特定支持度的频繁项集。算法本身不难，java萌新我却花费了一天的时间，特此记录。算法描述我们目的是求出项数为K的频繁项集即L(K)。Apriori算法的核心步骤是：L(K-1)通过自连接求出项数为K的候选项集合C(...
Java实现Apriori算法进行关联规则挖掘
木子的博客
12-14 2万+
实验描述: 对指定数据集进行关联规则挖掘，选择适当的挖掘算法，编写程序实现，提交程序和结果报告。 数据集： retail.txt ，根据数据集中的数据利用合适的挖掘算法得到频繁项集，并计算置信度，求出满足置信度的所有的关联规则 retail.txt中每个数字表示一种商品的ID，一个{}内的表示一次交易 实验环境和编程语言： 本实验使用的编程语言为：Java 编程环境为：Intellij
Apriori算法的java实现
marho
08-28 2569
介绍 Apriori算法是一个经典的数据挖掘算法，Apriori的单词的意思是"先验的"，说明这个算法是具有先验性质的，就是说要通过上一次的结果推导出下一次的结果，这个如何体现将会在下面的分析中会慢慢的体现出来。Apriori算法的用处是挖掘频繁项集的，频繁项集粗俗的理解就是找出经常出现的组合，然后根据这些组合最终推出我们的关联规则。 Apriori算法原理 Apriori算法是一种逐层搜索
Java实现Apriori算法
weixin_45685353的博客
06-22 5093
简介： Apriori算法是第一个关联规则挖掘算法，也是最经典的算法。它利用逐层搜索的迭代方法找出数据库中项集的关系，以形成规则，其过程由连接（类矩阵运算）与剪枝（去掉那些没必要的中间结果）组成。该算法中项集的概念即为项的集合。包含K个项的集合为k项集。项集出现的频率是包含项集的事务数，称为项集的频率。如果某项集满足最小支持度，则称它为频繁项集。 基本思想： 首先扫描数据库中所需要进行分析的数据，在设置完支持度以及置信度以后，在最小支持度的支持下产生频繁项，即统计所有项目集中包含一个或一个以上的元素频数，找
【机器学习】Apriori算法详解（关联规则挖掘）
最新发布
酒酿小圆子呀～
05-18 761
Apriori 算法是最为经典的关联规则挖掘算法之一。关于关联规则有个很常见的例子：啤酒与尿布。沃尔玛在分析销售记录时，发现啤酒和尿布经常一起被购买，于是他们调整了货架，把两者放在一起，结果真的提升了啤酒的销量。关联规则分析也称为购物篮分析，最早是为了发现超市销售数据库中不同的商品之间的关联关系。关联规则是反映一个事物与其他事物之间的关联性，若多个事物之间存在着某种关联关系，那么其中的一个事物就能通过其他事物预测到。这里要注意，关联规则不是因果关系，有可能有因果关系，有可能没有。定义 1。
用java实现Apriori算法
luohualiushui1的专栏
02-16 1942
首先大家了解一下Apriori算法，如下： Apriori算法 是一种最有影响的挖掘布尔关联规则频繁项集的算法。其核心是基于两阶段频集思想的递推算法。该关联规则在分类上属于单维、单层、布尔关联规则。在这里，所有支持度大于最小支持度的项集称为频繁项集，简称频集。 该算法的基本思想 是：首先找出所有的频集，这些项集出现的频繁性至少和预定义的最小支持度一样。然后由频集产生强关联规则，这些规则必须满足...
apriori java_频繁模式挖掘apriori算法介绍及Java实现
weixin_31629913的博客
02-12 464
频繁模式是频繁地出如今数据集中的模式(如项集、子序列或者子结构)。比如。频繁地同一时候出如今交易数据集中的商品(如牛奶和面包)的集合是频繁项集。一些基本概念支持度：support(A=>B)=P(A并B)置信度：confidence(A=>B)=P(B|A)频繁k项集：假设项集I的支持度满足提前定义的最小支持度阈值。则称I为频繁项集，包括k个项的项集称为k项集。算法思想Apriori算...
Apriori算法 java实现
05-28
`apriori.java`是Apriori算法的Java实现文件。这个文件可能包含了以下关键部分： 1. 数据预处理：从Excel文件中读取数据，转换成项集（如商品列表）。 2. 支持度计算：定义一个函数来计算项集的支持度，这是评估项集...
Apriori算法java实现
04-18
Apriori算法java实现，本人自己毕业设计用的不解释！ 上次传的有人说用不了，表示很惊讶！ ！本人亲测能用的
Apriori算法Java实现全套
04-11
Apriori算法java实现全套---------------------------------------------------------------------------------------
java实现频繁集_数据挖掘--频繁集测试--Apriori算法--java实现
weixin_32243309的博客
02-28 202
[ 关联规则挖掘用于寻找给定数据集中项之间的有趣的关联或相关关系。 关联规则揭示了数据项间的未知的依赖关系，根据所挖掘的关联关系，可以从� ...]2013年11月19日注：以下算法中，combine算法实现不正确，应该是从已有的频繁中来产生。需要进一步修改=====================================================================...
Apriori算法(java实现代码)
07-26
编程实现Apriori算法(java),可使用Apriori算法从事务数据库中挖掘频繁项集的方法；（测试数据从1K到10W）
Java实现的Apriori算法（附测试数据）
04-23
用Java语言实现的apriori算法，算法分为2步：计算频繁N项集；得出关联规则。
java实现Apriori算法
01-21
java实现Apriori算法，原始数据集存储在dataset.txt文件中
Apriori算法完整Java代码
11-19
Apriori算法是一种挖掘关联规则的频繁项集算法，其核心思想是通过候选集生成和情节的向下封闭检测两个阶段来挖掘频繁项集。而且算法已经被广泛的应用到商业、网络安全等各个领域。 完整的Java代码实现。
apriori java_Apriori算法的JAVA实现
weixin_34571972的博客
02-12 247
1 packageapriori;2 import java.io.*;3 import java.util.*;4 public classApriori {5 public static voidmain(String[] args) {6 long t=System.currentTimeMillis();7 File f=new File("E:/T...
Apriori算法详解之【二、伪代码和例子】
热门推荐
lizhengnanhua的专栏
06-09 5万+
上一篇文章中对Apriori算法进行了简单的描述（Apriori算法详解之【一、相关概念和核心步骤】http://blog.csdn.net/lizhengnanhua/article/details/9061755），现在用伪代码实现，及对经典例子进行描述（红兰PPT上之摘抄）。 一、Apriori算法伪代码实现： 伪代码描述： // 找出频繁 1 项集 L1 =find
apriori算法java实现
04-13
在Java语言中，常用的Apriori算法的实现方式有两种：基于内存和基于数据库。其中，基于内存的实现方式要求计算机具有足够大的内存空间，而基于数据库的实现方式则需要使用数据库来存储交易数据和频繁项集信息。具体...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值