TF-IDF算法的java实现

最新推荐文章于 2024-03-10 17:55:41 发布
最新推荐文章于 2024-03-10 17:55:41 发布
阅读量3.4k 收藏 2
点赞数 2
分类专栏： 数据挖掘 文章标签： 文本分类 TF-IDF 算法
本文详细介绍了TF-IDF算法的基本原理与实现步骤，并通过具体示例展示了如何使用Java进行TF-IDF算法的编程实现。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

转载地址：http://xwrwc.blog.163.com/blog/static/46320003201010634132451/

一、算法简介

        TF-IDF（term frequency–inverse document frequency）。

        TFIDF的主要思想是：如果某个词或短语在一篇文章中出现的频率TF高，并且在其他文章中很少出现，则认为此词或者短语具有很好的类别区分能力，适合用来分类。TFIDF实际上是：TF*IDF，TF词频(Term Frequency)，IDF反文档频率(Inverse Document Frequency)。TF表示词条t在文档d中出现的频率。IDF的主要思想是：如果包含词条t的文档越少，IDF越大，则说明词条t具有很好的类别区分能力。

二、算法实现

1》主要文件

 package tfidf;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import jeasy.analysis.MMAnalyzer;

public class ReadFiles {

    private static List<String> fileList = new ArrayList<String>();
    private static HashMap<String, HashMap<String, Float>> allTheTf = new HashMap<String, HashMap<String, Float>>();
    private static HashMap<String, HashMap<String, Integer>> allTheNormalTF = new HashMap<String, HashMap<String, Integer>>();

    public static List<String> readDirs(String filepath) throws FileNotFoundException, IOException {
        try {
            File file = new File(filepath);
            if (!file.isDirectory()) {
                System.out.println("输入的参数应该为[文件夹名]");
                System.out.println("filepath: " + file.getAbsolutePath());
            } else if (file.isDirectory()) {
                String[] filelist = file.list();
                for (int i = 0; i < filelist.length; i++) {
                    File readfile = new File(filepath + "\\" + filelist[i]);
                    if (!readfile.isDirectory()) {
                        //System.out.println("filepath: " + readfile.getAbsolutePath());
                        fileList.add(readfile.getAbsolutePath());
                    } else if (readfile.isDirectory()) {
                        readDirs(filepath + "\\" + filelist[i]);
                    }
                }
            }

        } catch (FileNotFoundException e) {
            System.out.println(e.getMessage());
        }
        return fileList;
    }

    public static String readFiles(String file) throws FileNotFoundException, IOException {
        StringBuffer sb = new StringBuffer();
        InputStreamReader is = new InputStreamReader(new FileInputStream(file), "gbk");
        BufferedReader br = new BufferedReader(is);
        String line = br.readLine();
        while (line != null) {
            sb.append(line).append("\r\n");
            line = br.readLine();
        }
        br.close();
        return sb.toString();
    }

    public static String[] cutWord(String file) throws IOException {
        String[] cutWordResult = null;
        String text = ReadFiles.readFiles(file);
        MMAnalyzer analyzer = new MMAnalyzer();
        //System.out.println("file content: "+text);
        //System.out.println("cutWordResult: "+analyzer.segment(text, " "));
        String tempCutWordResult = analyzer.segment(text, " ");
        cutWordResult = tempCutWordResult.split(" ");
        return cutWordResult;
    }

    public static HashMap<String, Float> tf(String[] cutWordResult) {
        HashMap<String, Float> tf = new HashMap<String, Float>();//正规化
        int wordNum = cutWordResult.length;
        int wordtf = 0;
        for (int i = 0; i < wordNum; i++) {
            wordtf = 0;
            for (int j = 0; j < wordNum; j++) {
                if (cutWordResult[i] != " " && i != j) {
                    if (cutWordResult[i].equals(cutWordResult[j])) {
                        cutWordResult[j] = " ";
                        wordtf++;
                    }
                }
            }
            if (cutWordResult[i] != " ") {
                tf.put(cutWordResult[i], (new Float(++wordtf)) / wordNum);
                cutWordResult[i] = " ";
            }
        }
        return tf;
    }

    public static HashMap<String, Integer> normalTF(String[] cutWordResult) {
        HashMap<String, Integer> tfNormal = new HashMap<String, Integer>();//没有正规化
        int wordNum = cutWordResult.length;
        int wordtf = 0;
        for (int i = 0; i < wordNum; i++) {
            wordtf = 0;
            if (cutWordResult[i] != " ") {
                for (int j = 0; j < wordNum; j++) {
                    if (i != j) {
                        if (cutWordResult[i].equals(cutWordResult[j])) {
                            cutWordResult[j] = " ";
                            wordtf++;

                        }
                    }
                }
                tfNormal.put(cutWordResult[i], ++wordtf);
                cutWordResult[i] = " ";
            }
        }
        return tfNormal;
    }

    public static Map<String, HashMap<String, Float>> tfOfAll(String dir) throws IOException {
        List<String> fileList = ReadFiles.readDirs(dir);
        for (String file : fileList) {
            HashMap<String, Float> dict = new HashMap<String, Float>();
            dict = ReadFiles.tf(ReadFiles.cutWord(file));
            allTheTf.put(file, dict);
        }
        return allTheTf;
    }

    public static Map<String, HashMap<String, Integer>> NormalTFOfAll(String dir) throws IOException {
        List<String> fileList = ReadFiles.readDirs(dir);
        for (int i = 0; i < fileList.size(); i++) {
            HashMap<String, Integer> dict = new HashMap<String, Integer>();
            dict = ReadFiles.normalTF(ReadFiles.cutWord(fileList.get(i)));
            allTheNormalTF.put(fileList.get(i), dict);
        }
        return allTheNormalTF;
    }

    public static Map<String, Float> idf(String dir) throws FileNotFoundException, UnsupportedEncodingException, IOException {
        //公式IDF＝log((1+|D|)/|Dt|)，其中|D|表示文档总数，|Dt|表示包含关键词t的文档数量。
        Map<String, Float> idf = new HashMap<String, Float>();
        List<String> located = new ArrayList<String>();

        float Dt = 1;
        float D = allTheNormalTF.size();//文档总数
        List<String> key = fileList;//存储各个文档名的List
        Map<String, HashMap<String, Integer>> tfInIdf = allTheNormalTF;//存储各个文档tf的Map

        for (int i = 0; i < D; i++) {
            HashMap<String, Integer> temp = tfInIdf.get(key.get(i));
            for (String word : temp.keySet()) {
                Dt = 1;
                if (!(located.contains(word))) {
                    for (int k = 0; k < D; k++) {
                        if (k != i) {
                            HashMap<String, Integer> temp2 = tfInIdf.get(key.get(k));
                            if (temp2.keySet().contains(word)) {
                                located.add(word);
                                Dt = Dt + 1;
                                continue;
                            }
                        }
                    }
                    idf.put(word, Log.log((1 + D) / Dt, 10));
                }
            }
        }
        return idf;
    }

    public static Map<String, HashMap<String, Float>> tfidf(String dir) throws IOException {

        Map<String, Float> idf = ReadFiles.idf(dir);
        Map<String, HashMap<String, Float>> tf = ReadFiles.tfOfAll(dir);

        for (String file : tf.keySet()) {
            Map<String, Float> singelFile = tf.get(file);
            for (String word : singelFile.keySet()) {
                singelFile.put(word, (idf.get(word)) * singelFile.get(word));
            }
        }
        return tf;
    }
}

 2》辅助工具类

 package tfidf;

public class Log {

    public static float log(float value, float base) {
        return (float) (Math.log(value) / Math.log(base));
    }
}

3》测试类

 package tfidf;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

public class Main {

    public static void main(String[] args) throws IOException {

        Map<String, HashMap<String, Integer>> normal = ReadFiles.NormalTFOfAll("d:/dir");
        for (String filename : normal.keySet()) {
            System.out.println("fileName " + filename);
            System.out.println("TF " + normal.get(filename).toString());
        }

        System.out.println("-----------------------------------------");

        Map<String, HashMap<String, Float>> notNarmal = ReadFiles.tfOfAll("d:/dir");
        for (String filename : notNarmal.keySet()) {
            System.out.println("fileName " + filename);
            System.out.println("TF " + notNarmal.get(filename).toString());
        }

        System.out.println("-----------------------------------------");

        Map<String, Float> idf = ReadFiles.idf("d;/dir");
        for (String word : idf.keySet()) {
            System.out.println("keyword :" + word + " idf: " + idf.get(word));
        }

        System.out.println("-----------------------------------------");

        Map<String, HashMap<String, Float>> tfidf = ReadFiles.tfidf("d:/dir");
        for (String filename : tfidf.keySet()) {
            System.out.println("fileName " + filename);
            System.out.println(tfidf.get(filename));
        }
    }
}

 

三、实验数据

TFIDF算法java实现 - 珑儿 - 顾影自怜

四、实验结果

TFIDF算法java实现 - 珑儿 - 顾影自怜

  五、项目所需依赖

TFIDF算法java实现 - 珑儿 - 顾影自怜
 

 jar包下载地址：http://lvxiaolin1118.download.youkuaiyun.com/
注意jar包的版本，否则出现以下问题，请跟换如图版本的jar包。

六、常见疑问截图
1》没有加入lucene jar包

TFIDF算法java实现 - 珑儿 - 顾影自怜
 2》加入的lucene jar包版本与je分词jar包不对应
TFIDF算法java实现 - 珑儿 - 顾影自怜
 3》我自己又重新跑了一遍程序，正确的输入结果如下
TFIDF算法java实现 - 珑儿 - 顾影自怜
 
TFIDF算法java实现
12-10
需要的就下吧，其实源代码和jar包之前都有提供，这次花费了点时间整理了下。
Java:实现TFIDF算法（附带源码）
最新发布
欢迎来到我的博客！这里是一个专注于计算机技术的分享平台，涵盖编程开发、算法研究、系统架构、软件工程等多个领域。无论你是初学者还是资深开发者，都能在这里找到有价值的内容。
07-13 1399
Java:实现TFIDF算法（附带源码）
java tfidf_Java实现TFIDF算法
weixin_32540087的博客
02-13 343
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...
TFIDF算法Java实现
tianyunzqs的专栏
09-02 1505
一、算法简介 TF-IDF（term frequency–inverse document frequency）是一种用于信息检索与数据挖掘中常用的加权技术。TF-IDF的概念被公认为信息检索中最重要的发明。在搜索、文献分类和其他相关领域有着广泛的应用。其具体应用包括关键词提取、文本相似度、自动摘要。 TF-IDF的主要思想是如果某个词在一篇文章中出现的频率TF很高，而且在语料库中的其他文章中
自然语言处理系列之TF-IDF算法
热门推荐
Lionel的博客
12-16 2万+
TF-IDF算法TF-IDF（词频-逆文档频率）算法是一种统计方法，用以评估一字词对于一个文件集或一个语料库中的其中一份文件的重要程度。字词的重要性随着它在文件中出现的次数成正比增加，但同时会随着它在语料库中出现的频率成反比下降。该算法在数据挖掘、文本处理和信息检索等领域得到了广泛的应用，如从一篇文章中找到它的关键词。TFIDF的主要思想是：如果某个词或短语在一篇文章中出现的频率TF高，并且在其他文
TF-IDF理解及其Java实现代码实例
08-28
TF-IDF理解及其Java实现代码实例 TF-IDF（Term Frequency-Inverse Document Frequency）是一种常用的加权技术，在资讯检索和资讯探勘领域中具有非常重要的地位。TF-IDF的主要思想是：如果某个词或短语在一篇文章中...
TF-IDF算法解析与Python实现方法详解
09-21
TF-IDF算法是一种在信息检索和文本挖掘领域广泛使用的加权技术，它的核心目标是量化一个词在文档中的重要性。TF-IDF的计算由两部分组成：词频(Term Frequency, TF)和逆文档频率(Inverse Document Frequency, IDF)。 ...
TF-IDF.zip_TF-IDF java_java tf idf_tf idf_tf-idf
09-14
TF-IDF（Term Frequency-Inverse Document Frequency）是一种在信息...对于提供的文件"TF-IDF.zip"，可能包含的就是一个Java实现TF-IDF算法的代码示例或者相关项目，可以进一步研究学习如何在实际项目中应用TF-IDF。
TF-IDF算法java实现【转载】
u014333268的博客
08-11 1648
本文参考自: 原文地址 文章原地址：https://blog.youkuaiyun.com/lionel_fengj/article/details/53699903（侵权立删） TF-IDF算法 TF-IDF（词频-逆文档频率）算法是一种统计方法，用以评估一字词对于一个文件集或一个语料库中的其中一份文件的重要程度。字词的重要性随着它在文件中出现的次数成正比增加，但同时会随着它在语料库中出现的频率成反...
在scikit-learn中实现TF-IDF算法
weixin_51575130的博客
03-10 574
2.TF-IDF可以实现将 文本数据转换问数值向量表示（这里text数据为已经进行过手动分词处理，如传入整端数据得先分词处理。5.修改输出，print(vectorizer.get_feature_names_out()) ，打印特征词列表。左侧数据中前三个用于描述向量的第一个位置 分别对应第6个位置，第4个位置，第3个位置有向量值。4.修改输出 print(vectors.toarray())，输出每个文档的向量表示。（1）首先根据输入的多个文档，构建此表（默认去除单字词）1.首先安装配置环境。
java 实现的tfidf
06-14
自己实现的tfidf 自娱自乐，高手请闪开。谢谢
tfIDF文本分类算法的java代码
04-27
TF-IDF（term frequency–inverse document frequency）是一种用于信息检索与数据挖掘的常用加权技术。TF意思是词频(Term Frequency)，IDF意思是逆文本频率指数(Inverse Document Frequency)。
tfidf算法实现
11-17
简单实现tfidf算法，tfidf算法大家众所周知，就是用来计算词的权重的
TFIDF的java实现
07-23
TF-IDF的java实现，eclipse工程，直接可用
Java实现TF-IDF算法
qq_43965934的博客
05-27 3697
Java实现TF-IDF算法 TF-IDF是一种用于信息检索与数据挖掘的常用加权技术。TF是词频，IDF是逆文本频率指数。 原理： 简单来说就是一个词语在一篇文章中出现的次数TF，和该词语在语料库中所出现的频率IDF。 TF = 文章中该词出现次数/文章总词数 IDF = log(语料库中所有文章 / （语料库中出现该词汇的文章+1）) TF-IDF == TF*IDF，这个值越大，就说明这个词汇越可能是该文章的关键字，统计这类关键字以便于文章提出主旨。 Java代码实现: 首先我在写自己毕设的时候需要
TF-IDF java实现
gaoloudushang的专栏
08-11 1271
最近在学习推荐系统，在文本分类中要得到特征词，首先要获取tf-idf模型，搜索中也会用到tf-idf，有必要深入学习。首先来简单回顾一下tf-idf. 词频(TF)=某个词在文章中出现的次数 词频(TF)=某个词在文章中出现的次数/文章的总词数 或者： 词频(TF)=某个词在文章中出现的次数/该文出现次数最多的词的出现次数 逆文档率： TF-IDF： TF-IDF
Java:实现TFIDF算法（附完整源码）
希望我的博客，能帮上你解决学习中工作中所遇到的问题
01-28 484
Java:实现斗TFIDF算法（附完整源码）
TF-IDF算法Java实现详解与文档注解
Java实现TF-IDF算法通常涉及以下几个步骤： 1. **算法介绍**： - TF (Term Frequency)：简单地计算词语在文档中的出现次数，反映词语的重要性。 - IDF (Inverse Document Frequency)：计算一个词的逆文档频率，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值