tfidf 做自然语言理解的经常用。文档的作为权重计算,
许多初学者搞不清楚,权重计算特征选择。
针对文本分类而言 作为很简单的说明,特征选择都跟 类别有关比如 卡方 信息增益
而权重计算则与类别无关 比如 tfidf,tf
具体公式请参看 http://zh.wikipedia.org/wiki/TF-IDF
下面代码 写的比较粗陋。高手请避开。,,,,,
训练集可以上搜狗数据集上下载
写完以后感觉还是matlab 比较爽啊。。几行 解决java100多行的代码
public class TfIdfcomputor {
static String path = "E:\\训练集\\train\\";
static String vsmpath = "E:\\训练集\\vsm\\vsm.txt";
//static String path = "E:\\训练集\\SogouC.reduced\\Reduced";
// static String path ="E:\\训练集\\SogouC.mini\\Sample";
static Map<String, Map<String, Double>> DFdic = new HashMap();
static HashMap<String, List<Map<String, Double>>> dic = new HashMap();
static int DCOUNT;
static HashMap<String, Double> idfDic = new HashMap();
static Map<String, Map<String,Double>> TFIDFdic = new HashMap();
// static Map<String,List<String>> Simpledic= new HashMap();
public static void main(String[] args) throws IOException {
TfIdfcomputor tf = new TfIdfcomputor();
File[] Filelist = tf.readData(path);
DCOUNT = Filelist.length;
tf.readir(Filelist);
System.out.println("DFdic");
tf.computeIDF(dic);
tf.ComputeTFIDF();
/* for( String s :TFIDFdic.keySet())
{
Map map = TFIDFdic.get(s);
for(Object key :map.keySet() )
{
System.out.println("file "+s +"word "+ key+" tfidf "+map.get(key));
}
}*/
System.out.println("计算完毕开始输出");
tf.toLibData();
}
public void readir(File[] dir) throws IOException {
File[] fileList = dir;
for(File f :fileList){
System.out.println(f.getPath());
}
for (int i = 0; i < fileList.length; i++) {
File f = fileList[i];
//System.out.println(f.getPath());
String[] textword = cutWord(FiletoText(f.getPath()));
Map tf = computeTf(textword);
DFdic.put(f.getPath(), tf);
addDic(f.getPath(), tf);
}
System.out.println("TF PROCESS IS OVER");
System.out.println(dic.size());
for (Object o : dic.keySet()) {
System.out.println(o);
List list = dic.get(o);
for (Object l : list) {
Map pair = (Map) l;
for (Object p : pair.keySet()) {
/* System.out.println("key" + (String) o + "..."
+ "filepath...." + p + "tf..." + pair.get(p));*/
}
}
}
}
public String FiletoText(String path) throws IOException {
File f = new File(path);
BufferedReader br = new BufferedReader(new InputStreamReader(
new FileInputStream(f), "GB2312"));
String result = "";
String temp;
while ((temp = br.readLine()) != null) {
result = result + temp;
}
br.close();
return result;
}
public String[] cutWord(String text) throws IOException {
MMAnalyzer analyzer = new MMAnalyzer();
String temp = analyzer.segment(text, "|");
//System.out.println(temp);
String[] result = temp.split("\\|");
/*
* for(String s :result ) { System.out.println(s); }
*/
return result;
}
public HashMap<String, Double> computeTf(String[] textword) {
double size = textword.length;
HashMap<String, Integer> map = new HashMap();
for (int i = 0; i < textword.length; i++) {
//System.out.println(textword[i]);
if (map.containsKey(textword[i])) {
Integer count = map.get(textword[i]);
map.put(textword[i], count + 1);
} else {
map.put(textword[i], 1);
}
}
HashMap<String, Double> result = new HashMap();
for (Object o : map.keySet()) {
Integer temp = map.get(o);
//System.out.println((String) o + "count..." + temp);
result.put((String) o, temp / size);
//System.out.println((String) o + "tf..." + result.get(o));
}
return result;
}
public void addDic(String path, Map tf) {
//System.out.println(",,,,,,,,,,,,,");
for (Object o : tf.keySet()) {
if (dic.containsKey((String) o)) {
ArrayList list = (ArrayList) dic.get(o);
HashMap map = new HashMap();
map.put(path, (Double) tf.get((String) o));
list.add(map);
dic.put((String) o, list);
} else {
HashMap map = new HashMap();
map.put(path, (Double) tf.get((String) o));
ArrayList list = new ArrayList<Map<String, Double>>();
list.add(map);
dic.put((String) o, list);
}
}
}
public static File[] readData(String path) {
int size = 0;
File[] floderdir = new File(path).listFiles();
ArrayList list = new ArrayList();
for (File f : floderdir) {
// size = size+(int)f.length();
File[] childdir = f.listFiles();
for (File file : childdir) {
list.add(file);
}
}
size = list.size();
File[] fdir = new File[size];
for (int i = 0; i < size; i++) {
fdir[i] = (File) list.get(i);
}
return fdir;
}
public void computeIDF(HashMap<String, List<Map<String, Double>>> map) {
for (String key : map.keySet()) {
List list = map.get(key);
double hasCount = (double) list.size();
double idf = DCOUNT / hasCount;
idfDic.put(key, idf);
}
}
public void ComputeTFIDF() {
for (String filepath : DFdic.keySet()) {
Map filedic = DFdic.get(filepath);
HashMap<String, Double> tfidfPair = tfidfPair = new HashMap();
for (Object key : filedic.keySet()) {
double tf = (Double) filedic.get(key);
double idf = idfDic.get((String) key);
double tfidf = tf* Math.log(idf);
// System.out.println( key+"tf" + tf + "idf" + idf + "tfidf" + tfidf);
tfidfPair.put((String) key, tfidf);
}
// System.out.println(tfidfPair.size());
TFIDFdic.put(filepath, tfidfPair);
}
}
public void toLibData() throws IOException// 转化成libsvm格式;
{
int count = 0;
// int size =dic.entrySet().size();
List wordList = new ArrayList();
for (String word : dic.keySet()) {
wordList.add(word);
System.out.println("worddic add" + word);
}
// System.out.println("total word is"+wordList.size());
BufferedWriter bw = new BufferedWriter(
new FileWriter(new File(vsmpath)));
/*
* String [] wordList = new String[size]; int num=0; for(String word:
* dic.keySet()) { wordList[num]=word; num++;
* System.out.println("worddic add"+word); }
*/
String vsm = "";
for (String filename : TFIDFdic.keySet()) {
String lable = new File(filename).getParentFile().getName();
Map map = TFIDFdic.get(filename);// 获取某片文章对应的tfidf
vsm = vsm + lable + " ";
for (int i = 0; i < wordList.size(); i++) {
// System.out.println( "map.."+ map.size());
// String temp =wordList[i];
// System.out.println("temp"+ temp);
String temp = (String) wordList.get(i);
if (map.containsKey(temp)) {
vsm = vsm + i + ":" + map.get(temp) + " ";
// System.out.println(filename + "...." + temp + "...."+
// map.get(temp) + "...");
}
}
count++;
vsm = vsm + "\n";
bw.write(vsm);
vsm = "";
System.out.println("format" + " " + count + " " + filename);
}
System.out.println("begin output");
// BufferedWriter bw = new BufferedWriter(new FileWriter(new
// File(vsmpath)));
// bw.write(vsm);
System.out.println(".............................");
// System.out.println(vsm);
bw.close();
}
}
分享到:
相关推荐
Java实现TFIDF算法代码分享 TF-IDF(Term Frequency-Inverse Document Frequency)是一种用于资讯检索与资讯探勘的常用加权技术。TF-IDF是一种统计方法,用以评估一字词对于一个文件集或一个语料库中的其中一份文件...
4. **Java实现**:在Java中,我们可以创建类来处理TF-IDF的计算。首先,我们需要一个结构来存储每个文档的词汇表和它们的词频。然后,建立一个全局的文档集合,用于计算IDF。可以使用HashMap或者自定义的数据结构来...
自己实现的tfidf 自娱自乐,高手请闪开。谢谢
4. **Java实现TF-IDF** - 在Java中实现TF-IDF,我们可以使用开源库如Apache Lucene或者Mallet。Lucene是一个强大的全文搜索引擎库,它提供了TF-IDF的实现。Mallet则是一个机器学习工具包,也包含了TF-IDF的计算功能...
这里我们将详细讨论如何使用Java实现TFIDF进行文本聚类。 1. **TFIDF原理**: - **词频(Term Frequency, TF)**:表示一个词在文档中出现的频率,频率越高,说明这个词在文档中的重要性越大。 - **逆文档频率...
### TF-IDF算法Java实现详解 #### 一、算法简介 TF-IDF(Term Frequency-Inverse Document Frequency)是一种常用于信息检索与文本挖掘中的权重计算公式。它通过统计单词在文档中出现的频率以及在整个文集中的频率...
以下是对TF-IDF算法及其Java实现的详细解释: 1. **TF-IDF概念**: - **Term Frequency (TF)**:词频,表示一个词在文档中出现的次数。TF越高,这个词在文档中的重要性越大。 - **Inverse Document Frequency ...
压缩包中的"tfidf"文件可能是包含源代码、测试数据或者运行结果的文件。源代码可能包含了Mapper和Reducer的具体实现,测试数据可能是用于验证程序正确性的样本文档,而运行结果可能包括计算出的TF-IDF矩阵或其他形式...
利用java实现TFIDF,提取关键词,是术语提取、推荐系统等应用的基础之一。
在Java中,Apache Lucene是一个强大的全文搜索引擎库,它提供了TF-IDF的实现。 **TF-IDF的计算原理** 1. **词频(Term Frequency, TF)**:表示一个词在文档中出现的次数。一般来说,一个词在文档中出现的次数越多...
DBSCAN,全称为Density-Based Spatial Clustering of Applications with Noise,是一种基于密度的空间聚类算法,它能够发现...通过Java实现DBSCAN,开发者可以将其集成到自己的项目中,对大量数据进行有效的聚类分析。
在给定的压缩包文件"tfidf"中,可能包含了Java源代码,这些代码可能实现了上述的TF-IDF计算流程。具体代码实现可能会使用到Java的集合框架(如ArrayList、HashMap等)来存储词汇和它们的统计信息,以及数学库(如...
在实际应用中,Java实现KNN算法时,还需要考虑如何有效地存储和检索数据,以及如何优化搜索最近邻的过程,例如使用kd树、球树等空间索引结构。同时,为了提高效率,可以采用并行化处理,利用Java的多线程特性,如...
TF-IDF理解及其Java实现代码实例 TF-IDF(Term Frequency-Inverse Document Frequency)是一种常用的加权技术,在资讯检索和资讯探勘领域中具有非常重要的地位。TF-IDF的主要思想是:如果某个词或短语在一篇文章中...
在提供的"tfidf.java"文件中,可能包含了上述步骤的实现代码。具体实现细节会涉及到数据结构的选择(如使用哈希表或稀疏矩阵存储词频信息)、IDF计算的优化(如使用倒排索引加速)以及可能的优化策略,如平滑处理...
在Java实现KMeans算法时,需要注意以下几点: 1. **距离度量**:在文本数据中,通常使用余弦相似度来衡量两个文档之间的相似性,因为它是基于向量角度的,而非长度。 2. **向量化**:将文本转换为数值向量,如TF-...
在Java中,我们可以使用Apache Lucene这样的全文搜索引擎库来实现TF-IDF的计算。Lucene提供了一系列接口和类,如`TfidfSimilarity`和`TFIDFWeight`,可以方便地进行TF-IDF计算。此外,也可以自定义逻辑来实现这个...
在本文中,我们将深入探讨如何使用Java编程语言实现基于文本相似度匹配的文本聚类算法。文本聚类是自然语言处理领域的一个重要课题,它的目标是将大量无结构的文本数据按照其内在的语义关系划分为不同的类别,使得同...
除了结巴分词(java版本)所保留的原项目用于搜索引擎分词的功能(cut索引,切搜寻),我加入了tfidf的关键词提取功能,并且实现的效果和python的jieba版本的效果一模一样!(以下内容基于jieba-java版本README.md的...
TF-IDF(Term Frequency-Inverse Document Frequency)是一种在信息...对于提供的文件"TF-IDF.zip",可能包含的就是一个Java实现TF-IDF算法的代码示例或者相关项目,可以进一步研究学习如何在实际项目中应用TF-IDF。