`

TFIDF算法java实现

算法JavaJ#Blog 
阅读更多

转载自：

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实现 - 珑儿 - 顾影自怜

  

 

分享到：
| 作为java的一个库来使用wvtool
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    TFIDF算法 java实现

    ### TF-IDF算法Java实现详解 #### 一、算法简介 TF-IDF（Term Frequency-Inverse Document Frequency）是一种常用于信息检索与文本挖掘中的权重计算公式。它通过统计单词在文档中出现的频率以及在整个文集中的频率...

    tfidf算法 java代码

    tfidf算法 java代码/** * Docs : (docId, (word, tf-idf)*) */ public Map, Map, Float&gt;&gt; docs = new HashMap, Map, Float&gt;&gt;(); /** * Words: (word, idf) */ public Map, Float&gt; wordIdf = new HashMap, ...

    TFIDF的java实现

    4. **Java实现**：在Java中，我们可以创建类来处理TF-IDF的计算。首先，我们需要一个结构来存储每个文档的词汇表和它们的词频。然后，建立一个全局的文档集合，用于计算IDF。可以使用HashMap或者自定义的数据结构来...

    Java实现TFIDF算法代码分享

    Java实现TFIDF算法代码分享 TF-IDF（Term Frequency-Inverse Document Frequency）是一种用于资讯检索与资讯探勘的常用加权技术。TF-IDF是一种统计方法，用以评估一字词对于一个文件集或一个语料库中的其中一份文件...

    tfidf算法实现

    在提供的"tfidf.java"文件中，可能包含了上述步骤的实现代码。具体实现细节会涉及到数据结构的选择（如使用哈希表或稀疏矩阵存储词频信息）、IDF计算的优化（如使用倒排索引加速）以及可能的优化策略，如平滑处理...

    tfIDF文本分类算法的java代码

    TF-IDF（term frequency–inverse document frequency）是一种用于信息检索与数据挖掘的常用加权技术。TF意思是词频(Term Frequency)，IDF意思是逆文本频率指数(Inverse Document Frequency)。

    tfidf java实现

    以下是对TF-IDF算法及其Java实现的详细解释： 1. **TF-IDF概念**： - **Term Frequency (TF)**：词频，表示一个词在文档中出现的次数。TF越高，这个词在文档中的重要性越大。 - **Inverse Document Frequency ...

    java实现的KNN算法

    在实际应用中，Java实现KNN算法时，还需要考虑如何有效地存储和检索数据，以及如何优化搜索最近邻的过程，例如使用kd树、球树等空间索引结构。同时，为了提高效率，可以采用并行化处理，利用Java的多线程特性，如...

    DBSCAN算法（Java实现）

    DBSCAN，全称为Density-Based Spatial Clustering of Applications with Noise，是一种基于密度的空间聚类算法，它能够发现...通过Java实现DBSCAN，开发者可以将其集成到自己的项目中，对大量数据进行有效的聚类分析。

    TFIDF文章以及代码实现

    在给定的压缩包文件"tfidf"中，可能包含了Java源代码，这些代码可能实现了上述的TF-IDF计算流程。具体代码实现可能会使用到Java的集合框架（如ArrayList、HashMap等）来存储词汇和它们的统计信息，以及数学库（如...

    基于Hadoop的开发项目，包括分布式算法的实现和Hadoop项目，总共七个项目+源代码+文档说明

    3、基于MapReduce的TFIDF算法实现（java语言） 4、基于MapReduce的大矩阵乘法（java语言） 5、MapReduce基础Demo（java语言） 6、Hbase基础Demo（java语言） 7、HDFS基础Demo（java语言） - -------- 不懂运行，下载...

    Hadoop MapReduce实现tfidf源码

    本篇文章将详细讲解如何利用Hadoop MapReduce实现TF-IDF（Term Frequency-Inverse Document Frequency）算法，这是一种在信息检索和文本挖掘中用于评估一个词在文档中的重要性的统计方法。 首先，我们要理解TF-IDF...

    JAVA编写的基于文本相似度匹配的文本聚类

    在本文中，我们将深入探讨如何使用Java编程语言实现基于文本相似度匹配的文本聚类算法。文本聚类是自然语言处理领域的一个重要课题，它的目标是将大量无结构的文本数据按照其内在的语义关系划分为不同的类别，使得同...

    TF-IDF理解及其Java实现代码实例

    TF-IDF理解及其Java实现代码实例 TF-IDF（Term Frequency-Inverse Document Frequency）是一种常用的加权技术，在资讯检索和资讯探勘领域中具有非常重要的地位。TF-IDF的主要思想是：如果某个词或短语在一篇文章中...

    TFIDF文本聚类

    总结来说，使用Java实现TFIDF进行文本聚类，涉及到文本预处理、TF-IDF值计算、构建倒排索引、选择合适的聚类算法及优化策略等多个步骤。理解并熟练掌握这些步骤，对于处理大规模文本数据和挖掘隐藏信息具有重要意义...

    文本聚类 Kmeans方法java

    在Java实现KMeans算法时，需要注意以下几点： 1. **距离度量**：在文本数据中，通常使用余弦相似度来衡量两个文档之间的相似性，因为它是基于向量角度的，而非长度。 2. **向量化**：将文本转换为数值向量，如TF-...

    基于java+SSM+Python+TF-IDF算法用户画像购物网站商品推荐系统毕业设计源码+论文+数据库+使用文档（高分项目）

    基于java+SSM+Python+TF-IDF算法用户画像购物网站商品推荐系统毕业设计源码+论文+数据库+使用文档（高分项目）基于java+SSM+Python+TF-IDF算法用户画像购物网站商品推荐系统毕业设计源码+论文+数据库+使用文档（高分...

    java编写的文本分词后利用tfidf计算每个文档的单词的tfidf值，并保存到文件中.zip

    本项目涉及到的是使用Java编程语言进行文本分词，并通过TF-IDF(Term Frequency-Inverse Document Frequency)算法来计算每个文档中单词的权重，然后将这些值保存到文件中。下面我们将详细探讨这个过程。 首先，让...

    tfidf 基于Textrank算法的文本摘要….zip

    对于有一定基础或热衷于研究的人来说，可以在这些基础代码上进行修改和扩展，实现其他功能。 【沟通交流】： 有任何使用上的问题，欢迎随时与博主沟通，博主会及时解答。 鼓励下载和使用，并欢迎大家互相学习，共同...

Magicbox
Global site tag (gtag.js) - Google Analytics