Term Frequency (TF) e Term Frequency – Inverse Document Frequency (TF-IDF)

Nesse post vamos detalhar o que são esses dois algoritmos (TF e TF-IDF) e como eles podem ser usados para construir aplicações de PLN bastante úteis. É bastante comum quando utilizamos o Processamento de Linguagem Natural (PLN) termos de escolher quais são as abordagens que iremos utilizar. Atualmente existem três caminhos disponíveis. O primeiro deles é utilizar algoritmos estatísticos; O segundo é a utilização de algoritmos linguísticos. Por fim, podemos buscar aproveitar o melhor de dois mundos e utilizar abordagens híbridas.   

Gosta de aprender sobre processamento de linguagem natural? Clique aqui para ver mais.

Este tema já foi previamente discutido neste post. Vale a pena ler, caso você ainda não está familiarizado com este assunto.  A abordagem utilizada no algoritmo de Term Frequency (TF) e Term Frequency – Inverse Document Frequency (TF-IDF) é estatística.

De forma geral os dois algoritmos estão conectados pois o TF-IDF é uma extensão do TF.   

OBS: Existem vários frameworks de PLN que já implementam esses algoritmos e ajudam você a usá-los. Vale a pena procurar tanto em java quanto em python.

Term Frequency (TF)

A tradução do nome deste algoritmo já nos dá uma dica do que ele trata. A “frequência dos termos” é o processo de encontrar quantas vezes um termo foi repetido em uma sentença. 

Veja um exemplo bastante simples:  

Linda é linda.

Nesta sentença podemos afirmar que:  

• – Existem 3 de termos nesta sentença;
• – A frequência da palavra “Linda” é de 2/3;
• – A frequência da palavra “é” é de 1/3;    

Veja este algoritmo implementado na linguagem JAVA:

import Model.Word;
import Util.StringUtils;
import java.util.ArrayList;
import java.util.LinkedHashSet;

public class TermFrequency {
    //Gera um ArrayList de palavras
    public ArrayList<Word> getTermFrequency(String textToParse) {
        ArrayList<String> words =            
                         stringToArrayOfWords(textToParse);
        ArrayList<Word> retorno = new ArrayList<>();
        
        //Popula o array
        for (String s : words) {
            double count = 0;
            for (String i : words) {
                if (s.equals(i)) {
                    count++;
                }
            }
            if (!s.isEmpty()) {
                double a = count/words.size();
                retorno.add(new Word(s,count/words.size()));
            }
        }

        //Remove palavras repetidas usando HashSet

        LinkedHashSet<Word> temp = new LinkedHashSet<>();
        temp.addAll(retorno);
        retorno.clear();
        retorno.addAll(temp);
        return retorno;
    }

 //AUXILIAR METHODS
    public static ArrayList<String> stringToArrayOfWords(String contentToConvert) {
        ArrayList<String> words = new ArrayList<>();
        if (contentToConvert != null) {
            for (String s : contentToConvert.split(" ")) {
                words.add(s);
            }
        }
        return words;

    }

}

//Classe palavras

public class Word{

    private String word;
    private double frequency;

    public Word(String word, double frequency) {
        this.word = word;
        this.frequency = frequency;
    }

    public String getWord() {
        return word;
    }

    public void setWord(String word) {
        this.word = word;
    }

    public double getFrequency() {
        return frequency;
    }

    public void setFrequency(double frequency) {
        this.frequency = frequency;

    }
}

Term Frequency – Inverse Document Frequency (TF-IDF)  

Este algoritmo utiliza o mesmo conceito de frequência de termos, porém ele trabalha com uma adaptação visando melhorar o seu desempenho. Esta modificação foi pensada para tratar as palavras existentes no corpus analisado que não significam nada para o conjunto. Veja o exemplo abaixo:  

• Documento 1:  Eu sou homem.
• Documento 2:  Eu sou médico.
• Documento 3: Como um bom médico, eu fiz vários cursos de especialização.  

Se utilizarmos o algoritmo de TF (sem pré-processamento) podemos perceber que é possível que uma palavra ocorra em todos os documentos. Ex: “Eu”. Ao contrário disso também é possível, ou seja, é perfeitamente possível que uma palavra só ocorra em um documento. Ex: “fiz”.   

Ao analisar estes fatos é possível concluir que estes dois extremos são ruins para classificação de documentos. Se uma palavra ocorre em todos eles, não é possível dizer que aquela palavra é um diferencial. O mesmo podemos dizer se a palavra ocorre pouquíssimas vezes.   Para isso o algoritmo utiliza uma razão inversa para calcular a frequência destes termos. Observe o algoritmo:   TF * IDF

TF(t) = (Número de vezes que t aparece no documento) / (Número total de termos no documento).

IDF(t) = log_e(Número total de termos do documento/ Número de documentos que possuem o termo t).


Desta forma, tendem a se aproximar de zero, todos os termos que se repetem em todos os documentos ou aqueles que aparecem em apenas um documento.


Veja o algoritmo implementado em JAVA:

import Model.Word;
import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;

public class TermFrequencyIdf {

   public ArrayList<Word> 
                    getTermFrequencyIdf(
                          ArrayList<ArrayList<String>> docs, 
                          String textToParse) {
           ArrayList<String> wordsToParse =                    
                                stringToArrayOfWords(textToParse);
        ArrayList<Word> retorno = new ArrayList<>();

        //Contabiliza os termos
        for (String s : wordsToParse) {

            double count = 0;
            retorno.add(new Word(s,tfIdf(wordsToParse, docs, s)));
        }


       //Remove termos repetidos
        LinkedHashSet<Word> temp = new LinkedHashSet<>();
        temp.addAll(retorno);
        retorno.clear();
        retorno.addAll(temp);
        return retorno;
    }

    public double tf(ArrayList<String> doc, String term) {
        double result = 0;
        for (String word : doc) {
            if (term.equalsIgnoreCase(word)) {
                result++;
            }
        }
        return result / doc.size();
    }
    //Faz a contagem de acordo com a relação inversa dos documentos
    public double idf(ArrayList<ArrayList<String>> docs, String term) {
        double n = 0;
        for (List<String> doc : docs) {
            for (String word : doc) {
                if (term.equalsIgnoreCase(word)) {
                    n++;
                    break;
                }
            }
        }

        return Math.log(docs.size() / n);
    }


   //Retorna o valor do TF-IDF
    public double tfIdf(
                ArrayList<String> doc, 
                ArrayList<ArrayList<String>> docs, 
                String term) {
        return tf(doc, term) * idf(docs, term);
    }
}

Estes dois algoritmos são muito interessantes, porém é importante que para utiliza-los você tenha estudado um pouco de Pre-processamento. Visto que existem muitas palavras que são consideradas “lixo” por serem não significativas. Estes ruídos podem prejudicar a aplicação dos algoritmos descritos acima.