Vetorização em PLN

2. Técnicas de Vetorização (continuação)

2.2. TF-IDF (Term Frequency-Inverse Document Frequency)

O TF-IDF é uma técnica de vetorização que tenta medir a importância de uma palavra dentro de um conjunto de documentos. Ela considera duas informações:

• Term Frequency (TF): A frequência de uma palavra em um documento específico.
• Inverse Document Frequency (IDF): A importância da palavra no contexto do corpus, ou seja, quanto mais rara for a palavra em todos os documentos, mais importante ela é.

O TF-IDF é calculado pela multiplicação do Term Frequency (TF) com o Inverse Document Frequency (IDF). A fórmula para o cálculo do TF-IDF é a seguinte:

Onde:

• TF(t, d): Frequência do termo t no documento d.
• N: Número total de documentos no corpus.
• DF(t): Número de documentos que contêm o termo t.

O TF-IDF ajuda a reduzir a importância das palavras muito comuns, como "de", "para", "a", e destaca palavras que são mais relevantes para cada documento.

Corpus de Exemplo:

1. "O gato preto está na casa."
2. "O cachorro está na casa."
3. "O gato e o cachorro estão na casa."

Primeiro, calculamos a frequência de cada palavra em cada documento:

TF("gato", Doc 1) = 1

TF("preto", Doc 1) = 1

TF("está", Doc 1) = 1

TF("na", Doc 1) = 1

TF("casa", Doc 1) = 1

TF("cachorro", Doc 2) = 1

TF("gato", Doc 3) = 1

TF("cachorro", Doc 3) = 1

Agora, calculamos a IDF para cada palavra. Para o termo "gato", que aparece em 2 documentos de 3, a fórmula seria:

IDF("gato") = log(3 / 2) ≈ 0.1761

Repetimos esse cálculo para os outros termos, como "preto", "cachorro", etc.

Finalmente, multiplicamos o TF pelo IDF para calcular o TF-IDF final para cada palavra:

TF-IDF("gato", Doc 1) = 1 * 0.1761 ≈ 0.1761

Esse valor será maior para termos raros no corpus e menor para termos comuns. O resultado final pode ser usado para a vetorização de documentos.

from sklearn.feature_extraction.text import TfidfVectorizer
documents = [
"O gato preto está na casa."
"O cachorro está na casa."
"O gato e o cachorro estão na casa."
]
vectorizer = TfidfVectorizer()
X = vectorizer.fit_transform(documents)
print("Vocabulário:", vectorizer.get_feature_names_out())
print("Matriz TF-IDF:")
print(X.toarray())

2.3. Técnicas Avançadas de Vetorização: Word2Vec, GloVe e BERT

Embora o BoW e o TF-IDF sejam úteis em muitos cenários, eles possuem limitações, como a incapacidade de capturar relações semânticas complexas entre palavras. Para superar essas limitações, surgiram técnicas mais avançadas, como Word2Vec, GloVe e BERT, que representam as palavras em um espaço vetorial contínuo, onde palavras com significados semelhantes ficam mais próximas.

O Word2Vec é um modelo de aprendizado profundo que gera representações vetoriais de palavras. Existem duas abordagens principais para treinar o Word2Vec:

• Skip-Gram: Para uma palavra de entrada, o modelo tenta prever as palavras de contexto ao seu redor.
• CBOW (Continuous Bag of Words): Para um conjunto de palavras de contexto, o modelo tenta prever a palavra de entrada.

O Word2Vec captura não apenas o significado das palavras, mas também suas relações com outras palavras, como sinônimos e antonímias.

O GloVe é uma técnica que também gera representações vetoriais de palavras, mas se baseia em uma abordagem diferente do Word2Vec. Em vez de utilizar um modelo de rede neural, o GloVe foca em aprender as representações de palavras a partir de estatísticas globais de co-ocorrência de palavras em um corpus de texto.

O BERT é um modelo de linguagem baseado em transformers que considera o contexto bidirecional das palavras. Em vez de olhar apenas para o contexto anterior ou posterior das palavras, o BERT captura o contexto completo, o que melhora significativamente a qualidade das representações geradas para tarefas como análise de sentimentos, tradução automática, e outras tarefas de PLN.

3. Aplicações Práticas em Processamento de Linguagem Natural

3.1. Análise de Sentimentos

A análise de sentimentos é uma tarefa importante no PLN, que visa determinar a polaridade de um texto, ou seja, se ele expressa uma opinião positiva, negativa ou neutra. Usando as representações vetoriais de palavras geradas pelo Word2Vec, GloVe ou BERT, podemos treinar modelos de aprendizado de máquina para classificar os sentimentos dos textos.

Um modelo de análise de sentimentos pode ser treinado usando exemplos de textos rotulados com sentimentos, como análises de produtos ou postagens em redes sociais. A vetorização das palavras do texto é feita por uma das técnicas mencionadas, e em seguida, essas representações são passadas para um modelo de classificação, como um classificador SVM (Máquinas de Vetores de Suporte), redes neurais, ou até mesmo modelos pré-treinados, como o BERT, para classificar o sentimento.

from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score
from gensim.models import Word2Vec
import numpy as np

# Carregar e pré-processar os dados (corpus maior com 10 elementos)
texts = [
"Este produto é excelente",
"Horrível, não gostei",
"É bom, mas poderia ser melhor",
"Eu amei o produto, super recomendo",
"Péssima qualidade",
"Não gostei do atendimento",
"Muito bom, funcionou perfeitamente",
"O produto não correspondeu às expectativas",
"Gostei bastante, valeu a pena",
"Produto razoável, poderia ser melhor"
]
labels = [1, 0, 1, 1, 0, 0, 1, 0, 1, 0]  # 1: positivo, 0: negativo

# Treinar o modelo Word2Vec
processed_texts = [text.split() for text in texts]
model = Word2Vec(sentences=processed_texts, vector_size=100, window=5, min_count=1)

# Função para calcular o vetor médio de uma frase
def get_average_vector(text, model):
    words = text.split()
    word_vectors = [model.wv[word] for word in words if word in model.wv]
    if word_vectors:
        return np.mean(word_vectors, axis=0)
    else:
        return np.zeros(model.vector_size)

# Transformar textos em vetores médios de palavras
X = [get_average_vector(text, model) for text in texts]

# Dividir dados em treino e teste
X_train, X_test, y_train, y_test = train_test_split(X, labels, test_size=0.2)

# Treinar classificador SVM
svm = SVC(probability=True)
svm.fit(X_train, y_train)

# Avaliar a precisão
y_pred = svm.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print(f"Accuracy: {accuracy:.2f}")

# Função para avaliar nova frase
def avaliar_frase(frase, model, svm):
    frase_vector = get_average_vector(frase, model)    
    probabilidade = svm.predict_proba([frase_vector])[0][1]                                   
    sentimento = "Positivo" if probabilidade > 0.5 else "Negativo"

# Avaliar uma nova frase após o treinamento
nova_frase = input("
Digite uma nova frase para avaliar o sentimento: ")
avaliar_frase(nova_frase, model, svm)

3.2. Tradução Automática

A tradução automática é uma tarefa desafiadora no PLN, que visa traduzir um texto de um idioma para outro. Modelos como o Word2Vec, GloVe e principalmente o BERT, podem ser usados para representar palavras em diferentes idiomas e capturar as relações semânticas entre elas. Para tradução automática, utilizamos principalmente redes neurais, especialmente as redes neurais seq2seq (sequence-to-sequence) e transformers.

A arquitetura Transformer, por exemplo, tem sido fundamental no avanço da tradução automática, sendo a base de modelos como o BERT e o GPT (Generative Pre-trained Transformer). Esses modelos aprendem o contexto das palavras em um texto e conseguem gerar traduções precisas.

from transformers import MarianMTModel, MarianTokenizer

# Carregar o modelo e tokenizer para tradução de inglês para francês
model_name = "Helsinki-NLP/opus-mt-en-fr"
model = MarianMTModel.from_pretrained(model_name)
tokenizer = MarianTokenizer.from_pretrained(model_name)

# Traduzir uma sentença
sentence = "I love programming."
translated = tokenizer.encode(sentence, return_tensors="pt")
translation = model.generate(translated)

# Decodificar a tradução
translated_sentence = tokenizer.decode(translation[0], skip_special_tokens=True)
print("Tradução:", translated_sentence)

3.3. Outras Aplicações do PLN com Vetores de Palavras

Além da análise de sentimentos e tradução automática, as representações vetoriais de palavras têm uma variedade de outras aplicações, como:

• Classificação de Texto: Para categorizar documentos em diferentes classes (ex: notícias, emails, etc.).
• Geração de Texto: Modelos como GPT-3 geram texto coerente e fluido, útil para chatbots e assistentes virtuais.
• Respostas Automáticas: Sistemas de perguntas e respostas, como o ChatGPT, podem usar essas representações para entender e gerar respostas para perguntas complexas.
• Busca Semântica: Melhorar os motores de busca para entender a intenção por trás das palavras, ao invés de simplesmente buscar por correspondência exata.

from sklearn.naive_bayes import MultinomialNB
from sklearn.feature_extraction.text import CountVectorizer

# Carregar dados de exemplo para classificação
documents = ["Eu amo programação", "Este é um bom livro", "O filme foi um desastre"]
labels = [1, 1, 0]  # 1: positivo, 0: negativo

# Vetorização com CountVectorizer
vectorizer = CountVectorizer()
X = vectorizer.fit_transform(documents)

# Treinar o classificador Naive Bayes
classifier = MultinomialNB()
classifier.fit(X, labels)

# Prever a classe de um novo documento
new_doc = ["Eu detestei o filme"]
X_new = vectorizer.transform(new_doc)
prediction = classifier.predict(X_new)
print("Predição:", prediction)

Confira, neste link do Colab, os exemplos apresentados nesta postagem:Clique aqui para acessar.