S39L04 – Frequência de termos – Frequência inversa de documentos

html
Compreendendo TF-IDF: Aprimorando a Análise de Texto com Frequência de Termos–Frequência Inversa de Documentos
No domínio do Processamento de Linguagem Natural (PLN), analisar e compreender efetivamente os dados textuais é fundamental. Entre a miríade de técnicas disponíveis, Term Frequency-Inverse Document Frequency (TF-IDF) destaca-se como uma ferramenta poderosa para transformar texto em representações numéricas significativas. Este guia abrangente aprofunda-se no TF-IDF, explorando seus fundamentos, vantagens e implementação prática utilizando a biblioteca Scikit-learn do Python.

Índice

  O que é TF-IDF?
  Por que Usar TF-IDF?
  Como o TF-IDF Funciona
  Implementando TF-IDF em Python
    
      Configurando o Conjunto de Dados
      Usando CountVectorizer
      Aplicando TfidfVectorizer
    
  
  Exemplo Prático: Análise de Avaliações de Filmes
  Vantagens do TF-IDF
  Limitações do TF-IDF
  Conclusão
  Leitura Complementar


O que é TF-IDF?
Term Frequency-Inverse Document Frequency (TF-IDF) é uma estatística numérica que reflete a importância de uma palavra em um documento em relação a uma coleção de documentos (corpus). É amplamente utilizado em recuperação de informações, mineração de texto e PLN para avaliar quão relevante uma palavra é para um documento específico em um grande conjunto de dados.

Por que Usar TF-IDF?
Enquanto contagens simples de palavras (como aquelas de um CountVectorizer) fornecem frequências brutas de termos, elas não consideram a significância desses termos dentro do corpus. Palavras comuns como "o", "é" e "e" podem aparecer frequentemente, mas carregam pouco peso semântico. O TF-IDF aborda isso ajustando os pesos das palavras com base em sua distribuição nos documentos, enfatizando termos que são mais únicos e informativos.

Como o TF-IDF Funciona
O TF-IDF combina duas métricas:

  Term Frequency (TF): Mede com que frequência um termo aparece em um documento.

\[
\text{TF}(t, d) = \frac{\text{Número de vezes que o termo } t \text{ aparece no documento } d}{\text{Número total de termos no documento } d}
\]

  Inverse Document Frequency (IDF): Mede a importância de um termo considerando sua presença em todo o corpus.

\[
\text{IDF}(t, D) = \log \left( \frac{\text{Número total de documentos } N}{\text{Número de documentos que contêm o termo } t} \right)
\]
A pontuação TF-IDF é o produto de TF e IDF:
\[
\text{TF-IDF}(t, d, D) = \text{TF}(t, d) \times \text{IDF}(t, D)
\]
Esse cálculo assegura que termos comuns em muitos documentos recebam pesos mais baixos, enquanto termos únicos para documentos específicos recebam pesos mais altos.

Implementando TF-IDF em Python
A biblioteca Scikit-learn do Python oferece ferramentas robustas para implementar TF-IDF através do TfidfVectorizer. Abaixo está um guia passo a passo para aplicar TF-IDF a um conjunto de dados.

Configurando o Conjunto de Dados
Para nosso exemplo prático, utilizaremos um conjunto de dados de avaliações de filmes do Kaggle. Este conjunto de dados compreende 64.720 avaliações de filmes rotuladas como positivas (pos) ou negativas (neg).





		
		
			
			
Java
			
			import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split

# Import Data
data = pd.read_csv('movie_review.csv')
data.head()
			
				
					
				
					1
2
3
4
5
6
7
				
						import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
 
# Import Data
data = pd.read_csv('movie_review.csv')
data.head()
					
				
			
		



Exemplo de Saída:




		
		
			
			
Java
			
			   fold_id cv_tag  html_id  sent_id                                               text tag
0        0  cv000    29590        0  films adapted from comic books have had plenty...  pos
1        0  cv000    29590        1  for starters , it was created by alan moore ( ...  pos
2        0  cv000    29590        2  to say moore and campbell thoroughly researche...  pos
3        0  cv000    29590        3  the book ( or " graphic novel , " if you will ...  pos
4        0  cv000    29590        4  in other words , don't dismiss this film becau...  pos
			
				
					
				
					1
2
3
4
5
6
				
						   fold_id cv_tag  html_id  sent_id                                               text tag
0        0  cv000    29590        0  films adapted from comic books have had plenty...  pos
1        0  cv000    29590        1  for starters , it was created by alan moore ( ...  pos
2        0  cv000    29590        2  to say moore and campbell thoroughly researche...  pos
3        0  cv000    29590        3  the book ( or " graphic novel , " if you will ...  pos
4        0  cv000    29590        4  in other words , don't dismiss this film becau...  pos
					
				
			
		



Usando CountVectorizer
Antes de mergulhar no TF-IDF, é benéfico entender o CountVectorizer, que converte uma coleção de documentos de texto em uma matriz de contagens de tokens.





		
		
			
			
Java
			
			from sklearn.feature_extraction.text import CountVectorizer

corpus = [
    'This is the first document.',
    'This document is the second document.',
    'And this is the third one.',
    'Is this the first document?'
]

vectorizer = CountVectorizer()
X = vectorizer.fit_transform(corpus)
print(vectorizer.get_feature_names_out())
print(X.toarray())
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
				
						from sklearn.feature_extraction.text import CountVectorizer
 
corpus = [
    'This is the first document.',
    'This document is the second document.',
    'And this is the third one.',
    'Is this the first document?'
]
 
vectorizer = CountVectorizer()
X = vectorizer.fit_transform(corpus)
print(vectorizer.get_feature_names_out())
print(X.toarray())
					
				
			
		



Saída:




		
		
			
			
Java
			
			['and' 'document' 'first' 'is' 'one' 'second' 'the' 'third' 'this']
[[0 1 1 1 0 0 1 0 1]
 [0 2 0 1 0 1 1 0 1]
 [1 0 0 1 1 0 1 1 1]
 [0 1 1 1 0 0 1 0 1]]
			
				
					
				
					1
2
3
4
5
				
						['and' 'document' 'first' 'is' 'one' 'second' 'the' 'third' 'this']
[[0 1 1 1 0 0 1 0 1]
 [0 2 0 1 0 1 1 0 1]
 [1 0 0 1 1 0 1 1 1]
 [0 1 1 1 0 0 1 0 1]]
					
				
			
		



A partir da saída, observamos a contagem de cada palavra no corpus representada em forma de matriz numérica. No entanto, esse método não considera a importância de cada palavra no corpus.

Aplicando TfidfVectorizer
Para aprimorar nossa análise, o TfidfVectorizer transforma os dados de texto em características TF-IDF, ponderando os termos com base em sua importância.





		
		
			
			
Java
			
			from sklearn.feature_extraction.text import TfidfVectorizer

vectorizer = TfidfVectorizer()
X = vectorizer.fit_transform(corpus)
print(vectorizer.get_feature_names_out())
print(X.toarray())
			
				
					
				
					1
2
3
4
5
6
				
						from sklearn.feature_extraction.text import TfidfVectorizer
 
vectorizer = TfidfVectorizer()
X = vectorizer.fit_transform(corpus)
print(vectorizer.get_feature_names_out())
print(X.toarray())
					
				
			
		



Saída:




		
		
			
			
Java
			
			['and' 'document' 'first' 'is' 'one' 'second' 'the' 'third' 'this']
[[0.         0.46979139 0.58028582 0.38408524 0.         0.
  0.38408524 0.         0.38408524]
 [0.         0.6876236  0.         0.28108867 0.         0.53864762
  0.28108867 0.         0.28108867]
 [0.51184851 0.         0.         0.26710379 0.51184851 0.
  0.26710379 0.51184851 0.26710379]
 [0.         0.46979139 0.58028582 0.38408524 0.         0.
  0.38408524 0.         0.38408524]]
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						['and' 'document' 'first' 'is' 'one' 'second' 'the' 'third' 'this']
[[0.         0.46979139 0.58028582 0.38408524 0.         0.
  0.38408524 0.         0.38408524]
 [0.         0.6876236  0.         0.28108867 0.         0.53864762
  0.28108867 0.         0.28108867]
 [0.51184851 0.         0.         0.26710379 0.51184851 0.
  0.26710379 0.51184851 0.26710379]
 [0.         0.46979139 0.58028582 0.38408524 0.         0.
  0.38408524 0.         0.38408524]]
					
				
			
		



A matriz TF-IDF agora fornece uma representação ponderada, destacando a significância das palavras dentro de cada documento em relação a todo o corpus.

Preparando os Dados para Modelagem
Para construir modelos preditivos, dividiremos nosso conjunto de dados em conjuntos de treinamento e teste.





		
		
			
			
Java
			
			X = data['text']
y = data['tag']

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=1)
			
				
					
				
					1
2
3
4
				
						X = data['text']
y = data['tag']
 
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=1)
					
				
			
		



Exemplo Prático: Análise de Avaliações de Filmes
Aproveitando o TF-IDF, podemos construir modelos para classificar avaliações de filmes como positivas ou negativas. Abaixo está um fluxo de trabalho simplificado:

  Carregamento e Pré-processamento de Dados:
    
      Importar o conjunto de dados.
      Explorar a estrutura dos dados.
      Tratar quaisquer valores ausentes ou anomalias.
    
  
  Extração de Características:
    
      Usar TfidfVectorizer para converter os dados de texto em características TF-IDF.
      Opcionalmente, remover palavras de parada para aprimorar o desempenho do modelo:
    
    



		
		
			
			
Java
			
			vectorizer = TfidfVectorizer(stop_words='english')
			
				
					
				
					1
				
						vectorizer = TfidfVectorizer(stop_words='english')
					
				
			
		


  
  Construção do Modelo:
    
      Escolher um algoritmo de classificação (por exemplo, Regressão Logística, Máquinas de Vetores de Suporte).
      Treinar o modelo no conjunto de treinamento.
      Avaliar o desempenho no conjunto de teste.
    
  
  Métricas de Avaliação:
    
      Precisão, Revocação, F1-Score e ROC-AUC são métricas comuns para avaliar o desempenho do modelo.
    
  

Código de Exemplo:




		
		
			
			
Java
			
			from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report

# Vectorization
vectorizer = TfidfVectorizer(stop_words='english')
X_train_tfidf = vectorizer.fit_transform(X_train)
X_test_tfidf = vectorizer.transform(X_test)

# Model Training
model = LogisticRegression()
model.fit(X_train_tfidf, y_train)

# Predictions
y_pred = model.predict(X_test_tfidf)

# Evaluation
print(classification_report(y_test, y_pred))
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
				
						from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report
 
# Vectorization
vectorizer = TfidfVectorizer(stop_words='english')
X_train_tfidf = vectorizer.fit_transform(X_train)
X_test_tfidf = vectorizer.transform(X_test)
 
# Model Training
model = LogisticRegression()
model.fit(X_train_tfidf, y_train)
 
# Predictions
y_pred = model.predict(X_test_tfidf)
 
# Evaluation
print(classification_report(y_test, y_pred))
					
				
			
		



Exemplo de Saída:




		
		
			
			
Java
			
			              precision    recall  f1-score   support

         neg       0.85      0.90      0.87      3200
         pos       0.88      0.83      0.85      3200

    accuracy                           0.86      6400
   macro avg       0.86      0.86      0.86      6400
weighted avg       0.86      0.86      0.86      6400
			
				
					
				
					1
2
3
4
5
6
7
8
				
						              precision    recall  f1-score   support
 
         neg       0.85      0.90      0.87      3200
         pos       0.88      0.83      0.85      3200
 
    accuracy                           0.86      6400
   macro avg       0.86      0.86      0.86      6400
weighted avg       0.86      0.86      0.86      6400
					
				
			
		



O modelo demonstra um desempenho robusto, distinguindo com precisão entre avaliações positivas e negativas.

Vantagens do TF-IDF

  Destaque para Palavras Importantes: Ao ponderar termos raros mas significativos de forma mais alta, o TF-IDF aumenta o poder discriminatório das características.
  Redução de Ruído: Palavras comuns que oferecem pouco valor semântico são ponderadas de forma reduzida, levando a conjuntos de características mais limpos.
  Versatilidade: Aplicável em várias tarefas de PLN como classificação de documentos, clustering e recuperação de informações.
  Facilidade de Implementação: Bibliotecas como Scikit-learn simplificam a integração do TF-IDF em pipelines de dados.


Limitações do TF-IDF

  Representações Esparsas: As matrizes resultantes são frequentemente esparsas, o que pode ser computacionalmente intensivo para corpora muito grandes.
  Falta de Compreensão Semântica: O TF-IDF não captura o contexto ou as relações semânticas entre as palavras. Modelos avançados como Word2Vec ou BERT abordam essa limitação.
  Sensibilidade ao Tamanho do Documento: Documentos mais longos podem ter frequências de termos mais altas, potencialmente distorcendo as pontuações TF-IDF.


Conclusão
Term Frequency-Inverse Document Frequency (TF-IDF) é uma técnica essencial no conjunto de ferramentas de PLN, permitindo a transformação de dados textuais em representações numéricas significativas. Ao equilibrar a frequência dos termos dentro de documentos individuais contra sua prevalência em todo o corpus, o TF-IDF enfatiza as palavras mais informativas, aprimorando o desempenho de vários modelos baseados em texto.
Seja você construindo ferramentas de análise de sentimento, motores de busca ou sistemas de recomendação, compreender e aproveitar o TF-IDF pode elevar significativamente a eficácia e a precisão do seu projeto.

Leitura Complementar

  Documentação do TfidfVectorizer do Scikit-learn
  Tutorial de Trabalho com Dados de Texto do Scikit-learn
  Lista de Palavras de Parada do NLTK
  Wikipedia: Term Frequency–Inverse Document Frequency




Integrando insights teóricos e implementações práticas, este guia proporciona uma compreensão holística do TF-IDF, capacitando você a aproveitar suas capacidades em seus esforços de análise de texto.