TFIDF算法Java实现

最新推荐文章于 2024-06-13 23:22:01 发布
最新推荐文章于 2024-06-13 23:22:01 发布
阅读量1.3k 收藏 5
点赞数
分类专栏： NLP 文章标签： tfidf
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tianyunzqs/article/details/77783031
版权

一、算法简介

       TF-IDF（term frequency–inverse document frequency）是一种用于信息检索与数据挖掘中常用的加权技术。TF-IDF的概念被公认为信息检索中最重要的发明。在搜索、文献分类和其他相关领域有着广泛的应用。其具体应用包括关键词提取、文本相似度、自动摘要。

       TF-IDF的主要思想是如果某个词在一篇文章中出现的频率TF很高，而且在语料库中的其他文章中出现的频率很低，那么认为这个词对于这篇文章而言，携带的信息很多，也就越重要。因此词的重要性与词在文章中出现的频率成正比，与其在整个语料库中出现的频率成反比

       词频（term frequency，TF）指的是某一个给定的词语在给定文件中出现的频率。这个数字是对词数(term count)的归一化，以防止它偏向长的文件。（同一个词语在长文件里可能会比短文件有更高的词数，而不管该词语重要与否。）对于在某一特定文件里的词语  t_{i}  来说，它的重要性可表示为：

\mathrm{tf_{i,j}} = \frac{n_{i,j}}{\sum_k n_{k,j}}

      以上式子中 n_{i,j} 是该词 t_{i}  在文件d_{j}中的出现次数，而分母则是在文件d_{j}中所有字词的出现次数之和。

      逆向文档频率（inverse document frequency，IDF）是一个词语普遍重要性的度量。某一特定词语的IDF，可以由总文件数目除以包含该词语之文件的数目，再将得到的商取对数得到：

\mathrm{idf_{i}} = \log \frac{|D|}{|\{j: t_{i} \in d_{j}\}|}

其中

  • |D|：语料库中的文件总数
  • |\{ j: t_{i} \in d_{j}\}| ：包含词语 t_{i} 的文件数目（即 n_{i,j} \neq 0的文件数目）如果该词语不在语料库中，就会导致被除数为零，因此一般情况下使用1 + |\{j : t_{i} \in d_{j}\}|

然后

\mathrm{tf{}idf_{i,j}} = \mathrm{tf_{i,j}} \times \mathrm{idf_{i}}

      某一特定文件内的高词语频率，以及该词语在整个文件集合中的低文件频率，可以产生出高权重的TF-IDF。因此，TF-IDF倾向于过滤掉常见的词语，保留重要的词语。

二、Java实现

package com.zqs.tfidf;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

/**
 * TFIDF算法Java实现
 * @author tianyunzqs
 *
 */
public class TFIDF implements Serializable {

	private static final long serialVersionUID = -1944746523865028204L;
	// 存放所有词汇
	public static Set<String> vocab = new LinkedHashSet<String>();
	// 单词 -idf
	public Map<String, Double> word_idf = new HashMap<String, Double>();
	
	/**
	 * 训练样本的tfidf值，也即训练tfidf模型
	 * @param raw_data 训练数据，如：[[我们 是 中国 的公民], [我们 是 炎黄之孙]]（token为空格）
	 * @param token 单词之间分隔符
	 * @return 训练数据对应的tfidf数据列表
	 */
	public List<List<Double>> get_tfidf(List<String> raw_data, String token) {
		List<List<Double>> res = new ArrayList<List<Double>>();
		
		Map<String, Set<Integer>> word_docs = new HashMap<String, Set<Integer>>();
		Map<Integer, List<String>> doc_words = new HashMap<Integer, List<String>>();
		int doc_num = 0;
		
		for(String text : raw_data) {
			doc_num++;
			String[] words = text.split(token);
			doc_words.put(doc_num, Arrays.asList(words));
			for(String word : words) {
				vocab.add(word);
				if(word_docs.containsKey(word)) {
					word_docs.get(word).add(doc_num);
				} else {
					Set<Integer> docs = new HashSet<Integer>();
					docs.add(doc_num);
					word_docs.put(word, docs);
				}
			}
		}
		// 计算并存储每个word的idf值
		for(String word : vocab) {
			int doc_n = 0;
			if(word_docs.containsKey(word)) {
				doc_n = word_docs.get(word).size();
			}
			double idf = doc_words.size()*1.0 / (doc_n + 1);
			word_idf.put(word, idf);
		}
		
		// 计算每篇doc中，vocab中每个word的tfidf值
		for(Entry<Integer, List<String>> e : doc_words.entrySet()) {
			List<Double> tmp = new ArrayList<Double>();
			for(String word : vocab) {
				int word_n = Collections.frequency(e.getValue(), word);
				double tf = word_n*1.0 / e.getValue().size();
				double idf = word_idf.get(word);
				double tfidf = tf * idf;
				tmp.add(tfidf);
			}
			res.add(tmp);
		}

		return res;
	}
	
	/**
	 * 计算测试样本的tfidf值
	 * @param raw_data 测试数据
	 * @param token 单词之间的分隔符
	 * @return 测试数据的tfidf值
	 */
	public List<List<Double>> get_tfidf4test(List<String> raw_data, String token) {
		List<List<Double>> text_tfidf = new ArrayList<List<Double>>();
		for(String text : raw_data) {
			String[] words = text.split(token);
			List<String> words_list = Arrays.asList(words);
			List<Double> tmp = new ArrayList<Double>();
			for(String word : vocab) {
				int word_n = Collections.frequency(words_list, word);
				double tf = word_n*1.0 / words.length;
				double tfidf = tf * word_idf.get(word);
				tmp.add(tfidf);
			}
			text_tfidf.add(tmp);
		}
		return text_tfidf;
	}
	
	/**
	 * 序列化保存tfidf模型
	 * @param path 模型路径
	 */
	public void save_model(String path) {
		try {
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(path));
            oos.writeObject(this);
            oos.flush();
            oos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
	}
	
	/**
	 * 导出tfidf模型
	 * @param path 模型路径
	 * @return 训练好的TFIDF模型
	 */
	public TFIDF load_model(String path) {
		try {
            ObjectInputStream in = new ObjectInputStream(new FileInputStream(path));
            TFIDF tfidf = (TFIDF) in.readObject();
            in.close();
            return tfidf;
        } catch (IOException ee){
        	ee.printStackTrace();
        } catch (ClassNotFoundException e){
            e.printStackTrace();
        }
        return null;
	}

	public static void main(String[] args) {
		TFIDF tfidf = new TFIDF();
		List<String> res = new ArrayList<String>();
		res.add("我们 是 中国人");
		res.add("他们 是 美国人");
		res.add("你们 来自 哪里 呢 最 无论 不管 the 中国人");
		List<List<Double>> a = tfidf.get_tfidf(res, " ");
		System.out.println(vocab);
		for(List<Double> e : a) {
			System.out.println(e);
		}
		
		List<String> res2 = new ArrayList<String>();
		res2.add("我们 是 中国 公民");
		res2.add("我们 是 中国 的 公民");
		List<List<Double>> b = tfidf.get_tfidf4test(res2, " ");
		System.out.println(vocab);
		for(List<Double> e : b) {
			System.out.println(e);
		}
	}
}


参考资料：

1、https://baike.baidu.com/item/tf-idf/8816134?fr=aladdin

2、吴军. 数学之美[M]. 北京:人民邮电出版社, 2014

3、http://www.cnblogs.com/chenny7/p/4002368.html

4、http://blog.csdn.net/sangyongjia/article/details/52440063


tianyunzqs
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java:实现TFIDF算法（附完整源码）
希望我的博客，能帮上你解决学习中工作中所遇到的问题
01-28 407
Java:实现斗TFIDF算法（附完整源码）
TF-IDF算法讲解和Java实现
XiaoXiao_Yang77的博客
12-27 5594
一、 TF-IDF算法原理TF-IDF是一种用于信息检索（information retrieval）与文本挖掘（text mining）的常用加权技术。TF-IDF是一种统计方法，用以评估某个字词对于一个语料库中的其中一份文本的重要程度。字词的重要性随着它在文本中出现的次数成正比增加，但同时会随着它在语料库中出现的频率成反比下降。TF-IDF加权的各种形式常被搜寻引擎应用，作为文件与用户查询之间相
TF-IDF算法详解
最新发布
考研小钻风
06-13 1406
TF-IDF是一种经典且常用的文本特征提取方法，能够有效地衡量词语在文档中的重要性。虽然它存在一定的局限性，但在许多实际应用中依然表现出色。通过合理地结合TF和IDF，TF-IDF能够帮助我们从大量文本数据中提取有价值的信息。无论是在搜索引擎、推荐系统还是文本分类中，TF-IDF都扮演着重要的角色。
TFIDF算法java实现
12-10
需要的就下吧，其实源代码和jar包之前都有提供，这次花费了点时间整理了下。
java tfidf_Java实现TFIDF算法
weixin_32540087的博客
02-13 272
packageedu.heu.lawsoutput;importjava.io.BufferedReader;importjava.io.BufferedWriter;importjava.io.File;importjava.io.FileReader;importjava.io.FileWriter;importjava.util.HashMap;importjava.util.Map;imp...
Java实现TF-IDF算法
qq_43965934的博客
05-27 3139
Java实现TF-IDF算法 TF-IDF是一种用于信息检索与数据挖掘的常用加权技术。TF是词频，IDF是逆文本频率指数。 原理： 简单来说就是一个词语在一篇文章中出现的次数TF，和该词语在语料库中所出现的频率IDF。 TF = 文章中该词出现次数/文章总词数 IDF = log(语料库中所有文章 / （语料库中出现该词汇的文章+1）) TF-IDF == TF*IDF，这个值越大，就说明这个词汇越可能是该文章的关键字，统计这类关键字以便于文章提出主旨。 Java代码实现: 首先我在写自己毕设的时候需要
java 实现tfidf
kobe00712的专栏
06-14 189
tfidf 做自然语言理解的经常用。文档的作为权重计算， 许多初学者搞不清楚，权重计算特征选择。 针对文本分类而言 作为很简单的说明，特征选择都跟 类别有关比如 卡方 信息增益 而权重计算则与类别无关 比如 tfidf，tf 具体公式请参看 http://zh.wikipedia.org/wiki/TF-IDF 下面代码 写的比较粗陋。高手请避开。，，，，， 训练集可以上搜狗数据集上下载 写完以后...
TFIDF算法 java实现
03-05
### TF-IDF算法Java实现详解 #### 一、算法简介 TF-IDF（Term Frequency-Inverse Document Frequency）是一种常用于信息检索与文本挖掘中的权重计算公式。它通过统计单词在文档中出现的频率以及在整个文集中的频率...
Java实现TFIDF算法代码分享
08-28
Java实现TFIDF算法代码分享 TF-IDF（Term Frequency-Inverse Document Frequency）是一种用于资讯检索与资讯探勘的常用加权技术。TF-IDF是一种统计方法，用以评估一字词对于一个文件集或一个语料库中的其中一份文件...
tfidf算法 java代码
08-10
tfidf算法 java代码/** * Docs : (docId, (word, tf-idf)*) */ public Map, Map, Float>> docs = new HashMap, Map, Float>>(); /** * Words: (word, idf) */ public Map, Float> wordIdf = new HashMap, ...
tfidf java实现
12-05
tfidf java实现 适用于单篇文档提取关键词 实测效果还行
TFIDF的java实现
07-23
TF-IDF的java实现，eclipse工程，直接可用
tfIDF文本分类算法的java代码
04-27
TF-IDF（term frequency–inverse document frequency）是一种用于信息检索与数据挖掘的常用加权技术。TF意思是词频(Term Frequency)，IDF意思是逆文本频率指数(Inverse Document Frequency)。
java 实现的tfidf
06-14
自己实现的tfidf 自娱自乐，高手请闪开。谢谢
TF-IDF java实现
endless_yy的专栏
10-15 4259
最近在学习推荐系统，在文本分类中要得到特征词，首先要获取tf-idf模型，搜索中也会用到tf-idf，有必要深入学习。首先来简单回顾一下tf-idf. 词频(TF)=某个词在文章中出现的次数 词频(TF)=某个词在文章中出现的次数/文章的总词数 或者： 词频(TF)=某个词在文章中出现的次数/该文出现次数最多的词的出现次数 TF-IDF： TF-IDF=词频(T
自然语言处理系列之TF-IDF算法
热门推荐
Lionel的博客
12-16 2万+
TF-IDF算法TF-IDF（词频-逆文档频率）算法是一种统计方法，用以评估一字词对于一个文件集或一个语料库中的其中一份文件的重要程度。字词的重要性随着它在文件中出现的次数成正比增加，但同时会随着它在语料库中出现的频率成反比下降。该算法在数据挖掘、文本处理和信息检索等领域得到了广泛的应用，如从一篇文章中找到它的关键词。TFIDF的主要思想是：如果某个词或短语在一篇文章中出现的频率TF高，并且在其他文
Java实现TFIDF算法
a61140502935的博客
11-14 223
算法介绍 最近要做领域概念的提取，TFIDF作为一个很经典的算法可以作为其中的一步处理。 关于TFIDF算法的介绍可以参考这篇博客http://www.ruanyifeng.com/blog/2013/03/tf-idf.html。 计算公式比较简单，如下： 预处理 由于需要处理的候选词大约后3w+，并且语料文档数有1w+，直接挨个文本遍历的话很耗时，每个词处理时间都要一...
tf-idf算法的基本实现，java
beirdu的专栏
12-02 542
声明　　以下代码只是对tf-idf算法思想的基本实现，因此许多地方需待完善，总结如下： 　　1.实现逻辑问题：特殊位置、比如段首或者名词（相对于动词），应该有更大的权重； 　　2.分词前应该对文本进行基本处理：去掉标点，合适的方式调用分词接口，使得文本内容变大时能够分两次调用，但结果相同； 　　3.速度有待提升：总文本数一星期更新一次就行，关键词所在的文本现测量方式；实现　package de
代码实现tfidf算法
05-14
下面是一个简单的 Python 代码实现 tf-idf 算法的例子： ```python import math # 定义一个计算单词在文档中出现次数的函数 def count_word_in_doc(word, doc): count = 0 for w in doc.split(): if w == word:...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值