正文
频繁项集java代码 频繁项集的最大长度怎么算
提示：扫一扫查出行【扫一扫了解最新限行尾号】
复制提示
如何在JAVA中打印显示出R语言算法的结果
java中调用操作系统控制台（就是命令行），控制台里运行R脚本（可以在命令行里用Rscript，不一定要在R环境底下写）。
实在不行试试weka。
相关问答
Q1: 急需C++实现的Apriori算法代码
用C++ 实现的 可以 到下载 不过要注册扣积分的
算法实现
（一）核心类
Apriori算法的核心实现类为AprioriAlgorithm，实现的Java代码如下所示：
package org.shirdrn.datamining.association;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
/**
* B关联规则挖掘：Apriori算法/B
*
* P该算法基本上按照Apriori算法的基本思想来实现的。
*
* @author shirdrn
* @date 2009/07/22 22:56:23
* @msn shirdrn#hotmail.com(#→@)
* @qq 187071722
*/
public class AprioriAlgorithm {
private MapInteger, SetString txDatabase; // 事务数据库
private Float minSup; // 最小支持度
private Float minConf; // 最小置信度
private Integer txDatabaseCount; // 事务数据库中的事务数
private MapInteger, SetSetString freqItemSet; // 频繁项集集合
private MapSetString, SetSetString assiciationRules; // 频繁关联规则集合
public AprioriAlgorithm(
MapInteger, SetString txDatabase,
Float minSup,
Float minConf) {
this.txDatabase = txDatabase;
this.minSup = minSup;
this.minConf = minConf;
this.txDatabaseCount = this.txDatabase.size();
freqItemSet = new TreeMapInteger, SetSetString();
assiciationRules = new HashMapSetString, SetSetString();
}
/**
* 扫描事务数据库，计算频繁1-项集
* @return
*/
public MapSetString, Float getFreq1ItemSet() {
MapSetString, Float freq1ItemSetMap = new HashMapSetString, Float();
MapSetString, Integer candFreq1ItemSet = this.getCandFreq1ItemSet();
IteratorMap.EntrySetString, Integer it = candFreq1ItemSet.entrySet().iterator();
while(it.hasNext()) {
Map.EntrySetString, Integer entry = it.next();
// 计算支持度
Float supported = new Float(entry.getValue().toString())/new Float(txDatabaseCount);
if(supported=minSup) {
freq1ItemSetMap.put(entry.getKey(), supported);
}
}
return freq1ItemSetMap;
}
/**
* 计算候选频繁1-项集
* @return
*/
public MapSetString, Integer getCandFreq1ItemSet() {
MapSetString, Integer candFreq1ItemSetMap = new HashMapSetString, Integer();
IteratorMap.EntryInteger, SetString it = txDatabase.entrySet().iterator();
// 统计支持数，生成候选频繁1-项集
while(it.hasNext()) {
Map.EntryInteger, SetString entry = it.next();
SetString itemSet = entry.getValue();
for(String item : itemSet) {
SetString key = new HashSetString();
key.add(item.trim());
if(!candFreq1ItemSetMap.containsKey(key)) {
Integer value = 1;
candFreq1ItemSetMap.put(key, value);
}
else {
Integer value = 1+candFreq1ItemSetMap.get(key);
candFreq1ItemSetMap.put(key, value);
}
}
}
return candFreq1ItemSetMap;
}
/**
* 根据频繁(k-1)-项集计算候选频繁k-项集
*
* @param m 其中m=k-1
* @param freqMItemSet 频繁(k-1)-项集
* @return
*/
public SetSetString aprioriGen(int m, SetSetString freqMItemSet) {
SetSetString candFreqKItemSet = new HashSetSetString();
IteratorSetString it = freqMItemSet.iterator();
SetString originalItemSet = null;
while(it.hasNext()) {
originalItemSet = it.next();
IteratorSetString itr = this.getIterator(originalItemSet, freqMItemSet);
while(itr.hasNext()) {
SetString identicalSet = new HashSetString(); // 两个项集相同元素的集合(集合的交运算)
identicalSet.addAll(originalItemSet);
SetString set = itr.next();
identicalSet.retainAll(set); // identicalSet中剩下的元素是identicalSet与set集合中公有的元素
if(identicalSet.size() == m-1) { // (k-1)-项集中k-2个相同
SetString differentSet = new HashSetString(); // 两个项集不同元素的集合(集合的差运算)
differentSet.addAll(originalItemSet);
differentSet.removeAll(set); // 因为有k-2个相同，则differentSet中一定剩下一个元素，即differentSet大小为1
differentSet.addAll(set); // 构造候选k-项集的一个元素(set大小为k-1,differentSet大小为k)
candFreqKItemSet.add(differentSet); // 加入候选k-项集集合
}
}
}
return candFreqKItemSet;
}
/**
* 根据一个频繁k-项集的元素(集合)，获取到频繁k-项集的从该元素开始的迭代器实例
* @param itemSet
* @param freqKItemSet 频繁k-项集
* @return
*/
private IteratorSetString getIterator(SetString itemSet, SetSetString freqKItemSet) {
IteratorSetString it = freqKItemSet.iterator();
while(it.hasNext()) {
if(itemSet.equals(it.next())) {
break;
}
}
return it;
}
/**
* 根据频繁(k-1)-项集，调用aprioriGen方法，计算频繁k-项集
*
* @param k
* @param freqMItemSet 频繁(k-1)-项集
* @return
*/
public MapSetString, Float getFreqKItemSet(int k, SetSetString freqMItemSet) {
MapSetString, Integer candFreqKItemSetMap = new HashMapSetString, Integer();
// 调用aprioriGen方法，得到候选频繁k-项集
SetSetString candFreqKItemSet = this.aprioriGen(k-1, freqMItemSet);
// 扫描事务数据库
IteratorMap.EntryInteger, SetString it = txDatabase.entrySet().iterator();
// 统计支持数
while(it.hasNext()) {
Map.EntryInteger, SetString entry = it.next();
IteratorSetString kit = candFreqKItemSet.iterator();
while(kit.hasNext()) {
SetString kSet = kit.next();
SetString set = new HashSetString();
set.addAll(kSet);
set.removeAll(entry.getValue()); // 候选频繁k-项集与事务数据库中元素做差元算
if(set.isEmpty()) { // 如果拷贝set为空，支持数加1
if(candFreqKItemSetMap.get(kSet) == null) {
Integer value = 1;
candFreqKItemSetMap.put(kSet, value);
}
else {
Integer value = 1+candFreqKItemSetMap.get(kSet);
candFreqKItemSetMap.put(kSet, value);
}
}
}
}
// 计算支持度，生成频繁k-项集，并返回
return support(candFreqKItemSetMap);
}
/**
* 根据候选频繁k-项集，得到频繁k-项集
*
* @param candFreqKItemSetMap 候选k项集(包含支持计数)
*/
public MapSetString, Float support(MapSetString, Integer candFreqKItemSetMap) {
MapSetString, Float freqKItemSetMap = new HashMapSetString, Float();
IteratorMap.EntrySetString, Integer it = candFreqKItemSetMap.entrySet().iterator();
while(it.hasNext()) {
Map.EntrySetString, Integer entry = it.next();
// 计算支持度
Float supportRate = new Float(entry.getValue().toString())/new Float(txDatabaseCount);
if(supportRateminSup) { // 如果不满足最小支持度，删除
it.remove();
}
else {
freqKItemSetMap.put(entry.getKey(), supportRate);
}
}
return freqKItemSetMap;
}
/**
* 挖掘全部频繁项集
*/
public void mineFreqItemSet() {
// 计算频繁1-项集
SetSetString freqKItemSet = this.getFreq1ItemSet().keySet();
freqItemSet.put(1, freqKItemSet);
// 计算频繁k-项集(k1)
int k = 2;
while(true) {
MapSetString, Float freqKItemSetMap = this.getFreqKItemSet(k, freqKItemSet);
if(!freqKItemSetMap.isEmpty()) {
this.freqItemSet.put(k, freqKItemSetMap.keySet());
freqKItemSet = freqKItemSetMap.keySet();
}
else {
break;
}
k++;
}
}
/**
* P挖掘频繁关联规则
* P首先挖掘出全部的频繁项集，在此基础上挖掘频繁关联规则
*/
public void mineAssociationRules() {
freqItemSet.remove(1); // 删除频繁1-项集
IteratorMap.EntryInteger, SetSetString it = freqItemSet.entrySet().iterator();
while(it.hasNext()) {
Map.EntryInteger, SetSetString entry = it.next();
for(SetString itemSet : entry.getValue()) {
// 对每个频繁项集进行关联规则的挖掘
mine(itemSet);
}
}
}
/**
* 对从频繁项集集合freqItemSet中每迭代出一个频繁项集元素，执行一次关联规则的挖掘
* @param itemSet 频繁项集集合freqItemSet中的一个频繁项集元素
*/
public void mine(SetString itemSet) {
int n = itemSet.size()/2; // 根据集合的对称性，只需要得到一半的真子集
for(int i=1; i=n; i++) {
// 得到频繁项集元素itemSet的作为条件的真子集集合
SetSetString properSubset = ProperSubsetCombination.getProperSubset(i, itemSet);
// 对条件的真子集集合中的每个条件项集，获取到对应的结论项集，从而进一步挖掘频繁关联规则
for(SetString conditionSet : properSubset) {
SetString conclusionSet = new HashSetString();
conclusionSet.addAll(itemSet);
conclusionSet.removeAll(conditionSet); // 删除条件中存在的频繁项
confide(conditionSet, conclusionSet); // 调用计算置信度的方法，并且挖掘出频繁关联规则
}
}
}
/**
* 对得到的一个条件项集和对应的结论项集，计算该关联规则的支持计数，从而根据置信度判断是否是频繁关联规则
* @param conditionSet 条件频繁项集
* @param conclusionSet 结论频繁项集
*/
public void confide(SetString conditionSet, SetString conclusionSet) {
// 扫描事务数据库
IteratorMap.EntryInteger, SetString it = txDatabase.entrySet().iterator();
// 统计关联规则支持计数
int conditionToConclusionCnt = 0; // 关联规则(条件项集推出结论项集)计数
int conclusionToConditionCnt = 0; // 关联规则(结论项集推出条件项集)计数
int supCnt = 0; // 关联规则支持计数
while(it.hasNext()) {
Map.EntryInteger, SetString entry = it.next();
SetString txSet = entry.getValue();
SetString set1 = new HashSetString();
SetString set2 = new HashSetString();
set1.addAll(conditionSet);
set1.removeAll(txSet); // 集合差运算：set-txSet
if(set1.isEmpty()) { // 如果set为空，说明事务数据库中包含条件频繁项conditionSet
// 计数
conditionToConclusionCnt++;
}
set2.addAll(conclusionSet);
set2.removeAll(txSet); // 集合差运算：set-txSet
if(set2.isEmpty()) { // 如果set为空，说明事务数据库中包含结论频繁项conclusionSet
// 计数
conclusionToConditionCnt++;
}
if(set1.isEmpty() set2.isEmpty()) {
supCnt++;
}
}
// 计算置信度
Float conditionToConclusionConf = new Float(supCnt)/new Float(conditionToConclusionCnt);
if(conditionToConclusionConf=minConf) {
if(assiciationRules.get(conditionSet) == null) { // 如果不存在以该条件频繁项集为条件的关联规则
SetSetString conclusionSetSet = new HashSetSetString();
conclusionSetSet.add(conclusionSet);
assiciationRules.put(conditionSet, conclusionSetSet);
}
else {
assiciationRules.get(conditionSet).add(conclusionSet);
}
}
Float conclusionToConditionConf = new Float(supCnt)/new Float(conclusionToConditionCnt);
if(conclusionToConditionConf=minConf) {
if(assiciationRules.get(conclusionSet) == null) { // 如果不存在以该结论频繁项集为条件的关联规则
SetSetString conclusionSetSet = new HashSetSetString();
conclusionSetSet.add(conditionSet);
assiciationRules.put(conclusionSet, conclusionSetSet);
}
else {
assiciationRules.get(conclusionSet).add(conditionSet);
}
}
}
/**
* 经过挖掘得到的频繁项集Map
*
* @return 挖掘得到的频繁项集集合
*/
public MapInteger, SetSetString getFreqItemSet() {
return freqItemSet;
}
/**
* 获取挖掘到的全部的频繁关联规则的集合
* @return 频繁关联规则集合
*/
public MapSetString, SetSetString getAssiciationRules() {
return assiciationRules;
}
}
（二）辅助类
ProperSubsetCombination类是一个辅助类，在挖掘频繁关联规则的过程中，用于生成一个频繁项集元素的非空真子集，实现代码如下：
package org.shirdrn.datamining.association;
import java.util.BitSet;
import java.util.HashSet;
import java.util.Set;
/**
* B求频繁项集元素(集合)的非空真子集集合/B
* P从一个集合（大小为n）中取出m(m属于2~n/2的闭区间)个元素的组合实现类，获取非空真子集的集合
*
* @author shirdrn
* @date 2009/07/22 22:56:23
* @msn shirdrn#hotmail.com(#→@)
* @qq 187071722
*/
public class ProperSubsetCombination {
private static String[] array;
private static BitSet startBitSet; // 比特集合起始状态
private static BitSet endBitSet; // 比特集合终止状态，用来控制循环
private static SetSetString properSubset; // 真子集集合
/**
* 计算得到一个集合的非空真子集集合
*
* @param n 真子集的大小
* @param itemSet 一个频繁项集元素
* @return 非空真子集集合
*/
public static SetSetString getProperSubset(int n, SetString itemSet) {
String[] array = new String[itemSet.size()];
ProperSubsetCombination.array = itemSet.toArray(array);
properSubset = new HashSetSetString();
startBitSet = new BitSet();
endBitSet = new BitSet();
// 初始化startBitSet，左侧占满1
for (int i=0; in; i++) {
startBitSet.set(i, true);
}
// 初始化endBit，右侧占满1
for (int i=array.length-1; i=array.length-n; i--) {
endBitSet.set(i, true);
}
// 根据起始startBitSet，将一个组合加入到真子集集合中
get(startBitSet);
while(!startBitSet.equals(endBitSet)) {
int zeroCount = 0; // 统计遇到10后，左边0的个数
int oneCount = 0; // 统计遇到10后，左边1的个数
int pos = 0; // 记录当前遇到10的索引位置
// 遍历startBitSet来确定10出现的位置
for (int i=0; iarray.length; i++) {
if (!startBitSet.get(i)) {
zeroCount++;
}
if (startBitSet.get(i) !startBitSet.get(i+1)) {
pos = i;
oneCount = i - zeroCount;
// 将10变为01
startBitSet.set(i, false);
startBitSet.set(i+1, true);
break;
}
}
// 将遇到10后，左侧的1全部移动到最左侧
int counter = Math.min(zeroCount, oneCount);
int startIndex = 0;
int endIndex = 0;
if(pos1 counter0) {
pos--;
endIndex = pos;
for (int i=0; icounter; i++) {
startBitSet.set(startIndex, true);
startBitSet.set(endIndex, false);
startIndex = i+1;
pos--;
if(pos0) {
endIndex = pos;
}
}
}
get(startBitSet);
}
return properSubset;
}
/**
* 根据一次移位操作得到的startBitSet，得到一个真子集
* @param bitSet
*/
private static void get(BitSet bitSet) {
SetString set = new HashSetString();
for(int i=0; iarray.length; i++) {
if(bitSet.get(i)) {
set.add(array[i]);
}
}
properSubset.add(set);
}
}
测试用例
对上述Apriori算法的实现进行了简单的测试，测试用例如下所示：
package org.shirdrn.datamining.association;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import org.shirdrn.datamining.association.AprioriAlgorithm;
import junit.framework.TestCase;
/**
* BApriori算法测试类/B
*
* @author shirdrn
* @date 2009/07/22 22:56:23
* @msn shirdrn#hotmail.com(#→@)
* @qq 187071722
*/
public class TestAprioriAlgorithm extends TestCase {
private AprioriAlgorithm apriori;
private MapInteger, SetString txDatabase;
private Float minSup = new Float("0.50");
private Float minConf = new Float("0.70");
@Override
protected void setUp() throws Exception {
create(); // 构造事务数据库
apriori = new AprioriAlgorithm(txDatabase, minSup, minConf);
}
/**
* 构造模拟事务数据库txDatabase
*/
public void create() {
txDatabase = new HashMapInteger, SetString();
SetString set1 = new TreeSetString();
set1.add("A");
set1.add("B");
set1.add("C");
set1.add("E");
txDatabase.put(1, set1);
SetString set2 = new TreeSetString();
set2.add("A");
set2.add("B");
set2.add("C");
txDatabase.put(2, set2);
SetString set3 = new TreeSetString();
set3.add("C");
set3.add("D");
txDatabase.put(3, set3);
SetString set4 = new TreeSetString();
set4.add("A");
set4.add("B");
set4.add("E");
txDatabase.put(4, set4);
}
/**
* 测试挖掘频繁1-项集
*/
public void testFreq1ItemSet() {
System.out.println("挖掘频繁1-项集 : " + apriori.getFreq1ItemSet());
}
/**
* 测试aprioriGen方法，生成候选频繁项集
*/
public void testAprioriGen() {
System.out.println(
"候选频繁2-项集 ： " +
this.apriori.aprioriGen(1, this.apriori.getFreq1ItemSet().keySet())
);
}
/**
* 测试挖掘频繁2-项集
*/
public void testGetFreq2ItemSet() {
System.out.println(
"挖掘频繁2-项集 ：" +
this.apriori.getFreqKItemSet(2, this.apriori.getFreq1ItemSet().keySet())
);
}
/**
* 测试挖掘频繁3-项集
*/
public void testGetFreq3ItemSet() {
System.out.println(
"挖掘频繁3-项集 ：" +
this.apriori.getFreqKItemSet(
3,
this.apriori.getFreqKItemSet(2, this.apriori.getFreq1ItemSet().keySet()).keySet()
)
);
}
/**
* 测试挖掘全部频繁项集
*/
public void testGetFreqItemSet() {
this.apriori.mineFreqItemSet(); // 挖掘频繁项集
System.out.println("挖掘频繁项集 ：" + this.apriori.getFreqItemSet());
}
/**
* 测试挖掘全部频繁关联规则
*/
public void testMineAssociationRules() {
this.apriori.mineFreqItemSet(); // 挖掘频繁项集
this.apriori.mineAssociationRules();
System.out.println("挖掘频繁关联规则 ：" + this.apriori.getAssiciationRules());
}
}
测试结果：
挖掘频繁1-项集 : {[E]=0.5, [A]=0.75, [B]=0.75, [C]=0.75}
候选频繁2-项集 ： [[E, C], [A, B], [B, C], [A, C], [E, B], [E, A]]
挖掘频繁2-项集 ：{[A, B]=0.75, [B, C]=0.5, [A, C]=0.5, [E, B]=0.5, [E, A]=0.5}
挖掘频繁3-项集 ：{[E, A, B]=0.5, [A, B, C]=0.5}
挖掘频繁项集 ：{1=[[E], [A], [B], [C]], 2=[[A, B], [B, C], [A, C], [E, B], [E, A]], 3=[[E, A, B], [A, B, C]]}
挖掘频繁关联规则 ：{[E]=[[A], [B], [A, B]], [A]=[[B]], [B]=[[A]], [B, C]=[[A]], [A, C]=[[B]], [E, B]=[[A]], [E, A]=[[B]]}
从测试结果看到，使用Apriori算法挖掘得到的全部频繁项集为：
{1=[[E], [A], [B], [C]], 2=[[A, B], [B, C], [A, C], [E, B], [E, A]], 3=[[E, A, B], [A, B, C]]}
使用Apriori算法挖掘得到的全部频繁关联规则为：
{E}→{A}、{E}→{B}、{E}→{A,B}、{A}→{B}、{B}→{A}、{B,C}→{A}、{A,C}→{B}、{B,E}→{A}、{A,E}→{B}。
Q2: 请教高手hashmap用iterator迭代时 调用entrySet()怎么用啊？？
用C++ 实现频繁项集java代码的 可以 到下载 不过要注册扣积分的
算法实现
（一）核心类
Apriori算法的核心实现类为AprioriAlgorithm频繁项集java代码，实现的Java代码如下所示频繁项集java代码：
package org.shirdrn.datamining.association;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
/**
* B关联规则挖掘频繁项集java代码：Apriori算法/B
*
* P该算法基本上按照Apriori算法的基本思想来实现的。
*
* @author shirdrn
* @date 2009/07/22 22:56:23
* @msn shirdrn#hotmail.com(#→@)
* @qq 187071722
*/
public class AprioriAlgorithm {
private MapInteger, SetString txDatabase; // 事务数据库
private Float minSup; // 最小支持度
private Float minConf; // 最小置信度
private Integer txDatabaseCount; // 事务数据库中的事务数
private MapInteger, SetSetString freqItemSet; // 频繁项集集合
private MapSetString, SetSetString assiciationRules; // 频繁关联规则集合
public AprioriAlgorithm(
MapInteger, SetString txDatabase,
Float minSup,
Float minConf) {
this.txDatabase = txDatabase;
this.minSup = minSup;
this.minConf = minConf;
this.txDatabaseCount = this.txDatabase.size();
freqItemSet = new TreeMapInteger, SetSetString();
assiciationRules = new HashMapSetString, SetSetString();
}
/**
* 扫描事务数据库频繁项集java代码，计算频繁1-项集
* @return
*/
public MapSetString, Float getFreq1ItemSet() {
MapSetString, Float freq1ItemSetMap = new HashMapSetString, Float();
MapSetString, Integer candFreq1ItemSet = this.getCandFreq1ItemSet();
IteratorMap.EntrySetString, Integer it = candFreq1ItemSet.entrySet().iterator();
while(it.hasNext()) {
Map.EntrySetString
关于频繁项集java代码和频繁项集的最大长度怎么算的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。
