TF-IDF演算法

TF-IDF（詞頻-逆文件頻率）演算法是一種統計方法，用以評估一字詞對於一個檔案集或一個語料庫中的其中一份檔案的重要程度。字詞的重要性隨著它在檔案中出現的次數成正比增加，但同時會隨著它在語料庫中出現的頻率成反比下降。該演算法在資料探勘、文字處理和資訊檢索等領域得到了廣泛的應用，如從一篇文章中找到它的關鍵詞。

TFIDF的主要思想是：如果某個詞或短語在一篇文章中出現的頻率TF高，並且在其他文章中很少出現，則認為此詞或者短語具有很好的類別區分能力，適合用來分類。TF-IDF實際上就是 TF*IDF，其中 TF（Term Frequency），表示詞條在文章Document 中出現的頻率；IDF（Inverse Document Frequency），其主要思想就是，如果包含某個詞 Word的文件越少，則這個詞的區分度就越大，也就是 IDF 越大。對於如何獲取一篇文章的關鍵詞，我們可以計算這邊文章出現的所有名詞的 TF-IDF，TF-IDF越大，則說明這個名詞對這篇文章的區分度就越高，取 TF-IDF 值較大的幾個詞，就可以當做這篇文章的關鍵詞。

計算步驟

1. 計算詞頻（TF）

   詞頻=某個詞在文章中的出現次數文章總次數

2. 計算逆文件頻率（IDF）

   逆文檔頻率=log語料庫的文檔總數包含該詞的文檔數+1

3. 計算詞頻-逆文件頻率（TF-IDF）
   詞頻−逆文檔頻率=詞頻∗逆文檔頻率

程式碼示例

為了建立自己的語料庫，我從網上爬了100個 url 存放在本地的 txt 檔案中，
存放格式如下：

這就相當於存放了100篇文章，即語料庫的的文件總數是100。

• TF-IDF 演算法程式碼

package com.myapp.ml.nlp;

import org.ansj.domain.Term;
import org.ansj.splitWord.analysis.ToAnalysis;
import
 
 org.ansj.util.FilterModifWord;
import org.apache.commons.lang3.StringUtils;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

/**
 * Created by lionel on 16/12/15.
 */
 

public class TFIDFAlgorithm {
    /**
     * 根據檔案路徑，檔案中存放的100個網址的 url，獲取 url 路徑列表
     *
     * @param path 本地檔案路徑
     * @return 路徑列表
     */
    public List<String> readUrlFromText(String path) {
        if (StringUtils.isBlank(path)) {
            return null;
        }
        List<String> urls = new ArrayList<String>();
        try {
            BufferedReader reader = new BufferedReader(new FileReader(path));
            String line;
            while ((line = reader.readLine()) != null) {
                urls.add(line.trim());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return urls;
    }

    /**
     * 利用 Jsoup 工具，根據網址獲取網頁文字
     *
     * @param url 網址
     * @return 網頁文字
     */
    public String getTextFromUrl(String url) {
        if (StringUtils.isBlank(url)) {
            return null;
        }

        String text = "";
        try {
            Document document = Jsoup.connect(url).get();
            text = document.text();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return text.replace(" ", "");
    }

    /**
     * 運用 ansj 給文字分詞
     *
     * @param text 文字內容
     * @return 分詞結果
     */
    public List<Term> parse(String text) {
        if (StringUtils.isBlank(text)) {
            return null;
        }
        List<Term> terms = FilterModifWord.modifResult(ToAnalysis.parse(text));
        if (terms == null || terms.size() == 0) {
            return null;
        }
        return terms;
    }

    /**
     * 計算一篇文章分詞後除去標點符號後詞的總數
     *
     * @param terms 分詞後的集合
     * @return 一篇文章分詞後除去標點符號後詞的總數
     */
    private Integer countWord(List<Term> terms) {
        if (terms == null || terms.size() == 0) {
            return null;
        }
        for (int i = 0; i < terms.size(); i++) {
            if ("null".equals(terms.get(i).getNatureStr()) || terms.get(i).getNatureStr().startsWith("w")) {
                terms.remove(i);
            }
        }
        return terms.size();
    }

    /**
     * 計算詞頻 IF
     *
     * @param word  詞
     * @param terms 分詞結果集合
     * @return IF
     */
    public double computeTF(String word, List<Term> terms) {
        if (StringUtils.isBlank(word)) {
            return 0.0;
        }
        int count = 0;
        for (Term term : terms) {
            if (term.getName().equals(word)) {
                count += 1;
            }
        }
        return (double) count / countWord(terms);
    }

    /**
     * 統計詞語的逆文件頻率 IDF
     *
     * @param path 存放 url 的檔案路徑
     * @param word IDF
     */
    public double computeIDF(String path, String word) {
        if (StringUtils.isBlank(path) || StringUtils.isBlank(word)) {
            return 0.0;
        }

        List<String> urls = readUrlFromText(path);
        int count = 1;
        for (String url : urls) {
            String text = getTextFromUrl(url);
            if (text.contains(word)) {
                count += 1;
            }
        }
        return Math.log10((double) urls.size() / count);
    }

    /**
     * 計算詞頻-逆文件頻率 TF—IDF
     *
     * @param filePath 存放url的檔案路徑
     * @param terms    分詞結果集合
     * @param word     詞
     * @return TF—IDF
     */

    public Double computeTFIDF(String filePath, List<Term> terms, String word) {
        return computeTF(word, terms) * computeIDF(filePath, word);
    }
}

• 測試程式碼

package com.myapp.ml.nlp;

import org.ansj.domain.Term;
import org.junit.Test;

import java.util.List;

/**
 *測試詞語“語言”的 TF-IDF
 * Created by lionel on 16/12/15.
 */
public class TFIDFAlgorithmTest {
    @Test
    public void test() {
        TFIDFAlgorithm tfidfAlgorithm = new TFIDFAlgorithm();
        String filePath = "/Users/lionel/PycharmProjects/python-app/com/pythonapp/spider/output.txt";
        String url = "http://baike.baidu.com/item/Java/85979";
        String word = "語言";
        List<Term> terms = tfidfAlgorithm.parse(tfidfAlgorithm.getTextFromUrl(url));
        System.out.println("[【" + word + "】詞頻 ] " + tfidfAlgorithm.computeTF(word, terms));
        System.out.println("[【" + word + "】逆文件頻率 ] " + tfidfAlgorithm.computeIDF(filePath, word));
        System.out.println("[【" + word + "】詞頻-逆文件頻率 ] "+tfidfAlgorithm.computeTFIDF(filePath,terms,word));

    }
}

• 測試結果
  

本篇部落格描述的是我對 TF-IDF 演算法的理解，程式碼是對演算法過程簡單的實現，若有失偏頗，還請指出。