计算信息增益(Information Gain),考虑交叉feature

原创 2012年03月30日 18:05:21
 

import java.io.BufferedReader;
import java.io.FileReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

 

/**
 * 
 * @author qibaoyuan
 * 
 */
public class InformationGain {

	/**
	 * calculate the info(entrophy from a list of classes)
	 * 
	 * @param classes
	 *            字符类型的分类信息
	 * @return info entropy
	 */
	static Double calculateEntrophy(List<String> classes) {
		Double info = 0.0;
		try {
			// 总的个数
			int size = classes.size();

			// map to store the count of each unique class
			Map<String, Integer> counter = new HashMap<String, Integer>();

			// iter all the class
			for (String key : classes) {
				// already exists,incremental
				if (counter.containsKey(key.trim()))
					counter.put(key.trim(), counter.get(key.trim()) + 1);
				else
					// set 1
					counter.put(key.trim(), 1);
			}

			// iter the map
			for (Entry<String, Integer> entry : counter.entrySet()) {
				Double ratio = Double.parseDouble(Integer.toString((entry
						.getValue()))) / size;
				info -= ratio * (Math.log(ratio) / Math.log(2));
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return info;
	}

	/**
	 * 
	 * @param records
	 *            输入记录 example:{[我 n 1 0 0 0 0 0 YES],[是 n 0 0 0 0 0 0 NO]}
	 * @return
	 */
	static Map<Integer, Double> calculateIG(List<String[]> records,
			Boolean isSingleFeature) {
		Map<Integer, Double> index4select = new HashMap<Integer, Double>();
		try {
			// 1.计算总的info
			List<String> labels = new ArrayList<String>();
			int feature_size = 0;
			for (String[] arr : records) {
				String label = arr[arr.length - 1];
				labels.add(label);
				feature_size = arr.length - 1;

			}

			Map<Integer, List<Object>> features = PermutationTest.genPerLess(
					feature_size, 3);

			Double total = calculateEntrophy(labels);
			System.out.print("label的熵信息:");
			System.out.println(total);

			// 2.计算每个feature的entrophy
			// int i=0;
			for (Entry<Integer, List<Object>> entry1 : features.entrySet()) {

				Double info_i = 0.0;

				Map<String, List<String>> featureMap = new HashMap<String, List<String>>();

				// divide the records according to the feature
				for (String[] arr : records) {

					// get the feature
					String feature = "";
					if (entry1.getValue().size() > 1 && isSingleFeature)
						continue;
					for (Object obj : entry1.getValue()) {
						if (obj instanceof Integer)
							feature += arr[(Integer) obj];
					}

					// check whether if it's counted
					if (featureMap.containsKey(feature)) {
						List<String> featureList = featureMap.get(feature);
						featureList.add(arr[arr.length - 1]);
						featureMap.put(feature, featureList);
					} else {
						List<String> featureList = new ArrayList<String>();
						featureList.add(arr[arr.length - 1]);
						featureMap.put(feature, featureList);
					}

				}

				// calculate entrophy of each value of the feature
				for (Entry<String, List<String>> entry : featureMap.entrySet()) {

					Double score = calculateEntrophy(entry.getValue());

					info_i += (Double.parseDouble(Integer.toString(entry
							.getValue().size())) / records.size()) * score;
				}

				System.out.print("feature " + entry1.getKey() + " ig:");
				System.out.println(total - info_i);

				// ig=f-total
				index4select.put(entry1.getKey(), total - info_i);
			}

			// ///sort by the value
			ArrayList<Integer> keys = new ArrayList<Integer>(
					index4select.keySet());// 得到key集合
			final Map<Integer, Double> scoreMap_temp = index4select;
			Collections.sort(keys, new Comparator<Object>() {

				public int compare(Object o1, Object o2) {

					if (Double.parseDouble(scoreMap_temp.get(o1).toString()) < Double
							.parseDouble(scoreMap_temp.get(o2).toString()))
						return 1;

					if (Double.parseDouble(scoreMap_temp.get(o1).toString()) == Double
							.parseDouble(scoreMap_temp.get(o2).toString()))
						return 0;

					else
						return -1;
				}
			});

			int y = 0;

			for (Integer key : keys) {
				System.out.println(key + "" + features.get(key) + "= "
						+ scoreMap_temp.get(key));
			}
			// //////////////////////

		} catch (Exception e) {
			e.printStackTrace();
		}
		return index4select;
	}

	/**
	 * 从文件读入输入,计算每个feature的ig,最後一列是手工標註的label
	 * 
	 * @param file
	 *            存放手工标注语料的路径
	 */
	static void calculateIG(String file) {
		try {
			FileReader reader = new FileReader(file);
			BufferedReader br = new BufferedReader(reader);
			String line = null;
			List<String[]> lists = new ArrayList<String[]>();
			while ((line = br.readLine()) != null) {
				if (line.trim().length() == 0)
					continue;
				lists.add(line.split("\t"));
			}
			System.out.print(calculateIG(lists,false));
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		calculateIG("/home/qibaoyuan/qibaoyuan/lexo/cv/all.txt");
	}

}

版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

概率论与数据统计在分类预测中的原理介绍(信息增益、交叉熵等)

信息论 信息论(Information Theory)是概率论与数理统计的一个分枝。用于信息处理、信息熵、通信系统、数据传输、率失真理论、密码学、信噪比、数据压缩和相关课题。 基本概念 ...

【机器学习】信息量,信息熵,交叉熵,KL散度和互信息(信息增益)

首先先强烈推荐一篇外文博客Visual Information Theory这个博客的博主colah是个著名的计算机知识科普达人,之前非常著名的那篇LSTM讲解的文章也是他写的。这篇文章详细讲解了信息...

文本分类入门:特征选择算法之开方检验、信息增益;特征选择与特征权重计算的区别

文本分类入门(十)特征选择算法之开方检验:http://www.blogjava.net/zhenandaci/archive/2008/08/31/225966.html 文本分类入门(十一)特征...

一条SQL搞定信息增益的计算

http://www.cnblogs.com/qcloud1001/p/6735352.html 周东谕,2011年加入腾讯,现任职于腾讯互娱运营部数据中心,主要从事游戏相关的数据分析和挖掘工作。 ...

决策树算法定义,理解,信息增益计算方式

决策树算法:     参考网址:http://www.cnblogs.com/leoo2sk/archive/2010/09/19/decision-tree.html         ...

信息增益Java代码

  • 2015-04-27 17:13
  • 660B
  • 下载

使用LIBSVM对原始文本语料进行文本分类(二)——特征选择(信息增益方法)

使用LIBSVM对原始文本语料进行文本分类(二)——特征选择(信息增益方法)上一篇文章介绍了文本的预处理需要考虑的一些问题,那关于这一次实验,先在本篇文章的最开始说明,本次特征选择采用的方法是信息增益...

C4.5决策树-为什么可以选用信息增益来选特征

要理解信息增益,首先要明白熵是什么,开始很不理解熵,其实本质来看熵是一个度量值,这个值的大小能够很好的解释一些问题。 从二分类问题来看,可以看到,信息熵越是小的,说明分类越是偏斜(明确),可以理...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)