TF-IDF算法-golang实现

1、TF-IDF算法介绍

TF-IDF（term frequency–inverse document frequency，词频-逆向文件频率）是一种用于信息检索（information retrieval）与文本挖掘（text mining）的常用加权技术。

TF-IDF是一种统计方法，用以评估一字词对于一个文件集或一个语料库中的其中一份文件的重要程度。字词的重要性随着它在文件中出现的次数成正比增加，但同时会随着它在语料库中出现的频率成反比下降。

TF-IDF的主要思想是：如果某个单词在一篇文章中出现的频率TF高，并且在其他文章中很少出现，则认为此词或者短语具有很好的类别区分能力，适合用来分类。

（1）TF是词频(Term Frequency)

词频（TF）表示词条（关键字）在文本中出现的频率。

这个数字通常会被归一化(一般是词频除以文章总词数), 以防止它偏向长的文件。

公式：           即：

其中 ni,j 是该词在文件 dj 中出现的次数，分母则是文件 dj 中所有词汇出现的次数总和；

（2） IDF是逆向文件频率(Inverse Document Frequency)

逆向文件频率 (IDF) ：某一特定词语的IDF，可以由总文件数目除以包含该词语的文件的数目，再将得到的商取对数得到。

如果包含词条t的文档越少, IDF越大，则说明词条具有很好的类别区分能力。

公式：

其中，|D| 是语料库中的文件总数。 |{j:ti∈dj}| 表示包含词语 ti 的文件数目（即 ni,j≠0 的文件数目）。如果该词语不在语料库中，就会导致分母为零，因此一般情况下使用 1+|{j:ti∈dj}|

即：

（3）TF-IDF实际上是：TF * IDF

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

公式：

golang 实现TF-IDF 算法

 1 package main
 2
 3 import (
 4     "fmt"
 5     "math"
 6     "sort"
 7     "time"
 8 )
 9
10 type wordTfIdf struct {
11     nworld string
12     value  float64
13 }
14
15 func main() {
16     start := currentTimeMillis()
17     FeatureSelect(Load())
18
19
20      cost := currentTimeMillis() - start
21      fmt.Printf("耗时 %d ms ",cost)
22
23 }
24
25 type wordTfIdfs []wordTfIdf
26 type Interface interface {
27     Len() int
28     Less(i, j int) bool
29     Swap(i, j int)
30 }
31
32 func (us wordTfIdfs) Len() int {
33     return len(us)
34 }
35 func (us wordTfIdfs) Less(i, j int) bool {
36     return us[i].value > us[j].value
37 }
38 func (us wordTfIdfs) Swap(i, j int) {
39     us[i], us[j] = us[j], us[i]
40 }
41
42 func currentTimeMillis() int64 {
43     return time.Now().UnixNano() / 1000000
44 }
45 func FeatureSelect(list_words [][]string) {
46     docFrequency := make(map[string]float64, 0)
47     sumWorlds := 0;
48     for _, wordList := range list_words {
49         for _, v := range wordList {
50             docFrequency[v] += 1
51             sumWorlds++;
52         }
53     }
54     wordTf := make(map[string]float64)
55     for k, _ := range docFrequency {
56         wordTf[k] = docFrequency[k] / float64(sumWorlds)
57     }
58     docNum := float64(len(list_words))
59     wordIdf := make(map[string]float64)
60     wordDoc := make(map[string]float64, 0)
61     for k, _ := range docFrequency {
62         for _, v := range list_words {
63             for _, vs := range v {
64                 if (k == vs) {
65                     wordDoc[k] += 1
66                     break
67                 }
68             }
69         }
70     }
71     for k, _ := range docFrequency {
72         wordIdf[k] = math.Log(docNum / (wordDoc[k] + 1))
73     }
74     var wordifS wordTfIdfs
75     for k, _ := range docFrequency {
76         var wti wordTfIdf
77         wti.nworld = k
78         wti.value = wordTf[k] * wordIdf[k]
79         wordifS = append(wordifS, wti)
80     }
81     sort.Sort(wordifS)
82     fmt.Println(wordifS)
83 }
84
85 func Load() [][]string {
86     slice := [][]string{
87         {"my", "dog", "has", "flea", "problems", "help", "please"},
88         {"maybe", "not", "take", "him", "to", "dog", "park", "stupid"},
89         {"my", "dalmation", "is", "so", "cute", "I", "love", "him"},
90         {"stop", "posting", "stupid", "worthless", "garbage"},
91         {"mr", "licks", "ate", "my", "steak", "how", "to", "stop", "him"},
92         {"quit", "buying", "worthless", "dog", "food", "stupid"},
93     }
94     return slice
95 }