码迷,mamicode.com
首页 > 编程语言 > 详细

HotSpot关联规则算法(2)-- 挖掘连续型和离散型数据

时间:2015-03-15 00:48:30      阅读:239      评论:0      收藏:0      [点我收藏+]

标签:关联规则   hotspot   

本篇代码可在 (明天更新)下载。

前篇《HotSpot关联规则算法(1)-- 挖掘离散型数据》分析了离散型数据的HotSpot关联规则,本篇分析离散型和连续型数据的HotSpot关联规则挖掘。

1. 首先看下数据格式(txt文档):

@attribute outlook {sunny, overcast, rainy}
@attribute temperature numeric
@attribute humidity numeric
@attribute windy {TRUE, FALSE}
@attribute play {yes, no}
sunny,85,85,FALSE,no
sunny,80,90,TRUE,no
overcast,83,86,FALSE,yes
rainy,70,96,FALSE,yes
rainy,68,80,FALSE,yes
rainy,65,70,TRUE,no
overcast,64,65,TRUE,yes
sunny,72,95,FALSE,no
sunny,69,70,FALSE,yes
rainy,75,80,FALSE,yes
sunny,75,70,TRUE,yes
overcast,72,90,TRUE,yes
overcast,81,75,FALSE,yes
rainy,71,91,TRUE,no
此数据参考weka自带数据weather.arff,而且数据格式,比如写上@attribute 等都是参考weka的数据格式来的。下面代码中使用的数据格式如上所述,其格式描述如下:1)前m行以@attribute开头,代码m个属性,其中最后一个为目标属性;2)如果属性是数值型,则在attribute后面空格跟属性名,再空格跟numeric;如果是离散型,那么attribute后面空格跟属性名,再空格使用大括号把离散值括起来,离散值用逗号分隔;3)目标属性必须是离散型的(关于目标属性应该一定要属于离散型的这点要求,其实只是我代码里面这样说而已,一般的HotSpot算法并没有这个要求。如果目标属性一定要求是连续型的,可以在lz代码基础上进行修改)。

2. 数据读取

《HotSpot关联规则算法(1)》中的数据读取是针对离散型的数据的,所以需要进行修改,这里修改后只针对离散型数据进行编码,连续型数据保持即可,同时还需设置一个布尔数组指明属性列属于离散型还是连续型。其读取代码如下所示:

while ((tempString = reader.readLine()) != null) {
				// 第一行数据是标题
				if (tempString.indexOf(HSUtils.FILEFORMAT) == 0) {

					String attr = "";
					String[] attrStates = null;
					if (tempString.contains("{")) {
						attr = tempString.substring(
								HSUtils.FILEFORMAT.length(),
								tempString.indexOf("{")).trim();
						attrStates = tempString.substring(
								tempString.indexOf("{") + 1,
								tempString.indexOf("}")).split(",");
						for (int i = 0; i < attrStates.length; i++) {
							attrStates[i] = attrStates[i].trim();
						}
						numericList.add(false);
						this.attributeStates.put(attr, attrStates);// 在这里添加即可
					} else {// numeric
						if (tempString.contains("numeric")) {
							attr = tempString.substring(
									HSUtils.FILEFORMAT.length(),
									tempString.indexOf("numeric")).trim();
							numericList.add(true);
						} else {
							// error 数据格式错误
							throw new Exception("数据格式错误,请检查!");
						}

					}
					attrList.add(attr);
					line++;

					continue;
				}
				if (flag) {
					this.attributes = new String[line];
					this.isNumeric = new Boolean[line];
					attrList.toArray(this.attributes);// 复制值到数组中
					numericList.toArray(this.isNumeric);
					flag = false;
				}
				String[] tempStrings = tempString.split(splitter);
				lists.add(strArr2IntArr(tempStrings));
			}
这里只贴了while循环里面的代码,这里的代码即针对前面描述的数据格式规则进行变量初始化(其实,这里使用List存储转换后的数据,一般是可以使用数组来存储的,把List的数据转为数组即可,这样在后面的操作中可以更快,如果要优化,可以从这方面入手)。

3.  HotSpot关联规则树的节点定义说明:

由于这里增加了连续型属性数据,所以针对单个节点需增加一个布尔型变量lessThan,用于指明是要大于或者小于该节点数据,同时stateIndex应该是一个数值了(当前节点的值),而不是离散型数据状态的下标了。

4. 算法伪代码(建树过程)

在算法伪代码中的计算潜在节点时,针对连续型变量使用不同的方法,在weka源码中使用方法:evaluateNumeric来进行判断。在lz的代码中此部分是完全参考源码中的代码的,不过有一点就是在调用evaluateNumeric这个算法后,会针对某一列进行排序,即一个二维数组按某列进行全局排序。这个方法在weka源码中是使用Instances的quickSort方法进行排序的(使用了递归,没仔细看)。这里lz则是直接把List转为二维数组然后进行排序的,其方法如下:

/**
	 * 根据attrIndex进行排序,attrIndex必须是numeric的 此方法可能需要优化
	 * List 使用数组是否更快? 可以考虑使用数组
	 * @param intData
	 * @param attrIndex
	 * @return
	 */
	private List<float[]> sortBasedOnAttr(List<float[]> intData, final int attrIndex) {
		
		float[][] tmpData = new float[intData.size()][];
		intData.toArray(tmpData);

		Arrays.sort(tmpData,new Comparator<float[]>(){
			@Override
			public int compare(float[] o1, float[] o2) {
				if(o1[attrIndex]==o2[attrIndex]){
					return 0;
				}
				return o1[attrIndex]>o2[attrIndex]?1:-1;
			}
			
		});
		List<float[]> returnList = new ArrayList<float[]>();
		for (int i = 0; i < tmpData.length; i++) {
			returnList.add(tmpData[i]);
		}
		return returnList;
	}
同时,在递归构建孩子节点时,生成节点规则时,针对数值型和离散型其生成方式也是不同的,如下:

double[] newSplitVals = splitVals.clone();
			byte[] newTests = tests.clone();
			newSplitVals[attrStateSup.getAttrIndex()] = attrStateSup
					.getStateIndex() + 1;
			newTests[attrStateSup.getAttrIndex()] = isNumeric[attrStateSup.getAttrIndex()]?
				attrStateSup.isLessThan()?(byte)1:(byte)3:(byte) 2;

			HotSpotHashKey key = new HotSpotHashKey(newSplitVals, newTests);
在递归构建孩子节点时,使用的子数据集的生成方式也需要进行调整,如下:

/**
	 * 获取和splitAttributeIndex相同下标的属性以及stateIndex的所有数据
	 * 
	 * @param intData
	 * @param splitAttributeIndex
	 * @param splitValue
	 * @return
	 */
	private List<float[]> getSubData(List<float[]> intData,
			int splitAttributeIndex, float splitValue,boolean lessThan) {
		List<float[]> subData = new ArrayList<float[]>();
		for (float[] d : intData) {
			if(isNumeric[splitAttributeIndex]){
				if(lessThan){
					if (d[splitAttributeIndex] <= splitValue) {
		                subData.add(d);
		            }
				}else{
					if (d[splitAttributeIndex] > splitValue) {
		                subData.add(d);
		            }
				}
			}else{
				if (d[splitAttributeIndex] == splitValue) {
					subData.add(d);
				}
			}
		}
		return subData;
	}

节点的toString 方法,用于打印HotSpot关联规则树

/**
	 * 格式化输出
	 */
	public String toString(){
		String tmp = HSUtils.isNumeric(splitAttrIndex)?this.lessThan?" <= ":" > ":" = ";
		String attrState = HSUtils.isNumeric(splitAttrIndex)?String.valueOf(this.attrStateIndex):
			HSUtils.getAttrState(splitAttrIndex, (int)attrStateIndex);
 		return HSUtils.getAttr(this.splitAttrIndex)+tmp
				+attrState
				+"  ("+HSUtils.formatPercent(this.support)+" ["+this.stateCount+"/"+this.allCount+"])";
	}

在打印关联规则树时,同样需要判断当前的属性是离散型还是连续型的。


代码输出为:

文件读取完成,且属性和属性的各种状态初始化完成!
属性outlook的状态:	[sunny-->0,overcast-->1,rainy-->2,]
属性temperature的状态:	[numeric]
属性humidity的状态:	[numeric]
属性windy的状态:	[TRUE-->0,FALSE-->1,]
属性play的状态:	[yes-->0,no-->1,]

规则树如下:

play = no  (35.71% [5/14])
|	temperature > 83.0  (100.00% [1/1])
|	humidity > 90.0  (66.67% [2/3])
|	|	temperature > 70.0  (100.00% [2/2])
|	|	humidity <= 95.0  (100.00% [2/2])



分享,成长,快乐

脚踏实地,专注

转载请注明blog地址:http://blog.csdn.net/fansy1990



HotSpot关联规则算法(2)-- 挖掘连续型和离散型数据

标签:关联规则   hotspot   

原文地址:http://blog.csdn.net/fansy1990/article/details/44264141

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!