Neste artigo aprenderemos as técnicas de vetorização mais básicas, como a frequência de termos e o modelo Bag of Words (BoW). Vamos discutir como essas técnicas são usadas para representar textos como vetores numéricos, permitindo que os computadores processem e analisem linguagem natural.

Técnicas Básicas de Vetorização

Existem diversas técnicas para transformar textos em números, nessa viagem, os primeiros portos que visitaremos estão fortemente construídos sobre as técnicas primitivas de representação matemática de elementos linguísticos. Eu vou fazer o máximo de esforço para seguir um fluxo crescente de dificuldade. A atenta leitora não deve se assustar se achar que eu perdi o rumo. Se eu parecer perdido é porque lembrei de algo que precisa ser visto antes que possamos deixar um porto em direção a outro. As passagens serão compradas sempre que eu achar que ficou claro.

Frequência de Termos

Uma das formas mais básicas, quase intuitiva. de representar texto numericamente é através da frequência de termos. A ideia é contar quantas vezes cada palavra aparece em um documento ou conjunto de documentos e criar um vocabulário¹.

Antes de prosseguirmos com a vetorização de textos, precisamos formalizar o conceito de corpus. Em linguística computacional e processamento de linguagem natural, um corpus (plural corpora) é uma coleção estruturada de textos. Formalmente, definimos:

Nesta definição, cada $D_i$ é um documento individual e $N$ é o número total de documentos no corpus.

Cada documento $D_i$ é uma sequência ordenada de tokens ou palavras, que podem incluir palavras, números, sinais de pontuação e outros elementos significativos. Assim, podemos representar um documento $D_i$ como uma sequência de tokens:

Em processamento de linguagem natural, um token é a menor unidade de análise em um texto. Um token pode ser uma palavra, um número, um sinal de pontuação ou qualquer outra unidade significativa. Por exemplo, na frase “O gato preto.”, temos 4 tokens: “O”, “gato”, “preto” e “.”. O processo de dividir um texto em tokens é chamado de tokenização. A escolha de como definir e separar tokens é uma decisão importante que afeta todo o processamento subsequente. Considere, para ilustrar, a palavra composta “guarda-chuva” pode ser considerada como um único token ou como três tokens (“guarda”, “-“, “chuva”), dependendo das regras de tokenização adotadas. Em modelos modernos de processamento de linguagem natural, como o GPT e BERT, os tokens podem ser ainda mais granulares, incluindo partes de palavras, chamadas de subpalavras (subwords).

Neste caso, $w_j$ representa o $j$-ésimo token do documento e $m_i$ é o comprimento do documento $D_i$.

O vocabulário global $V$ do corpus será o conjunto de todos os tokens únicos que aparecem em qualquer documento. Dado por:

Neste cenário vamos considerar que a palavra vocabulário se refere ao conjunto de todas as palavras únicas presentes em um corpus de texto, ou em um único documento, dependendo da técnica de representação que você está utilizando.

Pense no vocabulário como sendo uma lista organizada de todas as palavras distintas que o seu modelo de linguagem conhece, ou que são relevantes para a tarefa que está estudando. Um vocabulário será sempre um conjunto finito de termos sem repetição.

Podemos definir a técnica de frequência de termos como: seja $D$ um documento, definimos o vocabulário $V$ de $D$ como o conjunto de todas as palavras, $w$, únicas em $D$. De tal forma que: para cada palavra $w \in V$, a frequência de termos $f(w, D)$ é o número de vezes que $w$ ocorre em $D$.

Para entender essa definição, imagine que temos um texto curto $D_1$: “O gato preto subiu no telhado. O gato dorme no telhado”.

O vocabulário $V_{D_1}$ de $D_1$ será dado por:

Já que temos:

• o documento: “O gato preto subiu no telhado. O gato dorme no telhado”.
• o vocabulário: $V_{D_1} = { \text{“o”}, \text{“gato”}, \text{“preto”}, \text{“subiu”}, \text{“no”}, \text{“telhado”}, \text{“dorme”} }$.
• Calculamos a frequência, $f$, de cada termo em $V_{D_1}$ e $D_1$ apenas contando quantas vezes os termos do vocabulário aparecem no texto. Sendo assim, temos:

Com essa contagem, podemos representar o documento $D_1$ como um vetor de frequências $\vec{v_{D_1}}$. Se ordenarmos as palavras de $V_{D_1}$ alfabeticamente, por exemplo., $V’_{D_1} = { \text{“dorme”}, \text{“gato”}, \text{“no”}, \text{“o”}, \text{“preto”}, \text{“subiu”}, \text{“telhado”} }$, então o vetor de frequências será dado por:

A sagaz leitora deve perceber que o vetor de frequência $\vec{v_{D_1}}$ reside no espaço vetorial inteiro $\mathbb{Z}^{ \vert V \vert }$, no qual, temos:

• $\vec{v_{D_1}}$ denota o vetor de frequência do documento $D_1$.
• $\mathbb{Z}$ representa o conjunto dos números inteiros, indicando que cada componente do vetor $\vec{v_{D_1}}$ é um número inteiro (neste caso, uma contagem de frequência).
• $ \vert V \vert $ representa a cardinalidade do vocabulário $V$, que é o número total de palavras únicas no vocabulário. Este valor $ \vert V \vert $ define a dimensionalidade do espaço vetorial.

Em notação matemática, podemos expressar isso como:

Essa representação simples captura algumas informações sobre a importância relativa das palavras no texto. Palavras que aparecem com mais frequência podem ser consideradas mais relevantes para o conteúdo do documento. Isso pouco.

Limitações da Representação Vetorial por Frequência de Palavras

A representação de textos usando apenas vetores de frequência apresenta limitações que comprometem sua eficácia no processamento de linguagem natural. Para compreender melhor estas limitações, vamos tentar entender onde estão as falhas.

Considere um documento $D$ representado por um vetor de frequências $\vec{v}_D$, onde cada componente $v_i$ corresponde à frequência de uma palavra $w_i$ no vocabulário. Matematicamente, temos:

onde $f(w_i,D)$ é a frequência da palavra $w_i$ no documento $D$.

O primeiro problema é a perda completa da estrutura sequencial da linguagem. Em português, por exemplo, a ordem das palavras é indispensável para o significado. Por exemplo, considere as frases:

“João ama Maria” e “Maria ama João”

Usando o algoritmo de frequência de termos, ambas as frases produziriam exatamente o mesmo vetor de frequência:

As componentes do vetor $\vec{v}$ correspondem às frequências de “João”, “ama” e “Maria”, respectivamente. Em um mundo perfeito, “João ama Maria” e “Maria ama João”. Porém, além do mundo não ser perfeito, como diria Drummond, o sentido de “João ama Maria” é muito diferente do sentido de “Maria ama João”.

Um segundo problema é a ausência de relações semânticas entre palavras. Palavras com significados similares ou com significados relacionados são tratadas como completamente independentes. Por exemplo, nas frases:

“O carro é veloz” e “O automóvel é rápido”

Embora estas frases sejam semanticamente equivalentes, seus vetores de frequência seriam completamente diferentes e ortogonais no espaço vetorial, sem qualquer medida de similaridade entre elas. Como as palavras são tratadas como dimensões independentes, e não há sobreposição de termos entre “carro”/”automóvel” e “veloz”/”rápido”, é possível que os vetores sejam ortogonais. A atenta leitora pode verificar este caso acompanhando o exemplo a seguir:

Exemplo 1: analisando os documentos compostos por “O carro é veloz” e “O automóvel é rápido”:

1. $D_1$: “O carro é veloz”
2. $D_2$: “O automóvel é rápido”

Os documentos $D_1$ e $D_2$ forma o corpus da nossa análise. Primeiro, construímos o vocabulário global $V_{global}$ unindo todas as palavras únicas em $D_1$ e $D_2$:

$V_{global} = { \text{“o”}, \text{“carro”}, \text{“é”}, \text{“veloz”}, \text{“automóvel”}, \text{“rápido”} }$

Ordenando alfabeticamente o vocabulário para definir a ordem das dimensões dos vetores:

$V’_{global} = { \text{“automóvel”}, \text{“carro”}, \text{“é”}, \text{“o”}, \text{“rápido”}, \text{“veloz”} }$

Agora, criamos os vetores de frequência $\vec{v_{D_1}}$ e $\vec{v_{D_2}}$ para cada documento, usando a ordem do vocabulário ordenado alfabeticamente. Lembre-se que cada posição do vetor corresponderá a uma palavra no vocabulário ordenado, e o valor desta posição será a frequência daquela palavra no documento.

Para $D_1$ = “O carro é veloz”, teremos:

Portanto, o vetor de frequência para $D_1$ será dado por:

Para $D_2$ = “O automóvel é rápido”, teremos:

Portanto, o vetor de frequência para $D_2$ será:

Podemos usar estes vetores para verificar a similaridade entre eles usando o produto escalar. Começamos pela ortogonalidade.

Em álgebra linear, dois vetores $\vec{u}$ e $\vec{v}$ são ditos ortogonais se o seu produto escalar for igual a zero. Matematicamente, a ortogonalidade é definida como:

\[\vec{u} \cdot \vec{v} = \vec{u}^T \vec{v} = \sum_{i=1}^{n} u_i v_i = 0\]

na qual $n$ é a dimensão dos vetores.

Vamos calcular o produto escalar dos vetores de frequência $\vec{v_{D_1}}$ e $\vec{v_{D_2}}$:

Neste caso, o produto escalar de $\vec{v_{D_1}}$ e $\vec{v_{D_2}}$ é 2, que é diferente de zero. Portanto, os vetores $\vec{v_{D_1}}$ e $\vec{v_{D_2}}$ não são ortogonais. Ou seja existe alguma similaridade direcional entre eles. Estes vetores não são ortogonais porque compartilham os termos “o” e “é”.

O produto escalar sendo positivo indica que os vetores tendem a apontar na mesma direção. Quanto maior o valor positivo, maior a similaridade em termos de direção.

Vetores ortogonais não possuem qualquer similaridade direcional. Porém, mesmo que os vetores não sejam ortogonais, a similaridade medida apenas pelo produto escalar, ou outras medidas baseadas em frequência, ainda seria limitada.

Vetores de frequência capturam sobreposições de palavras literais, mas não a relação semântica subjacente. “Carro” e “automóvel”, “veloz” e “rápido” são sinônimos, mas em representações de frequência, eles são tratados como palavras completamente distintas. A semântica, sentido da palavra no documento, se perde.

A questão da polissemia² também é completamente ignorada na representação vetorial por frequência. Considere a palavra “banco” nas frases:

“Sentei no banco da praça” e “Fui ao banco sacar dinheiro”

O vetor de frequências trataria estas ocorrências do termo banco como idênticas, apesar de seus significados serem drasticamente diferentes. Matematicamente, isto significa que estamos mapeando diferentes significados para o mesmo componente do vetor, perdendo informação semântica.

Outro problema sério é o tratamento de negações. As frases:

“O filme é bom” e “O filme não é bom”

Produziriam vetores muito similares, diferindo apenas pela presença do termo “não”. A natureza oposta de seus significados seria praticamente indistinguível na representação vetorial. Os dois vetores terão, praticamente, a mesma direção e amplitude. Como a atenta leitora pode ver no exemplo a seguir:

Exemplo 2: vamos analisar os documentos “O filme é bom” e “O filme não é bom”.

Começamos definindo os documentos:

1. $D_1$: “O filme é bom”
2. $D_2$: “O filme não é bom”

Construímos o vocabulário global $V_{global}$ a partir de todas as palavras únicas presentes em $D_1$ e $D_2$:

$V_{global} = { \text{“o”}, \text{“filme”}, \text{“é”}, \text{“bom”}, \text{“não”} }$

Dado o vocabulário, podemos ordená-lo alfabeticamente para definir a ordem das dimensões dos vetores:

$V’_{global} = { \text{“bom”}, \text{“é”}, \text{“filme”}, \text{“não”}, \text{“o”} }$

A cardinalidade do vocabulário é $ \vert V’_{global} \vert = 5$, o que significa que nossos vetores de frequência terão 5 dimensões.

Neste ponto, podemos criar os vetores de frequência $\vec{v_{D_1}}$ e $\vec{v_{D_2}}$ para cada documento, seguindo a ordem das palavras em $V’_{global}$.

Para $D_1$ = “O filme é bom”:

O vetor de frequência para $D_1$ é:

Para $D_2$ = “O filme não é bom”:

O vetor de frequência para $D_2$ é:

Uma vez que os vetores estejam definidos, podemos analisar os vetores $\vec{v_{D_1}}$ e $\vec{v_{D_2}}$ em termos de produto escalar e magnitude, e discutir a similaridade entre eles.

a) Produto Escalar: calculamos o produto escalar de $\vec{v_{D_1}}$ e $\vec{v_{D_2}}$:

Para serem ortogonais, o produto escalar deveria ser zero. Como $\vec{v_{D_1}} \cdot \vec{v_{D_2}} = 4 \neq 0$, os vetores não são ortogonais.

O produto escalar é $4$, um valor positivo e relativamente alto, considerando as magnitudes dos vetores. Isso sugere alguma similaridade entre os vetores no espaço vetorial. Eles tendem a mesma direção.

b) Magnitudes: calculamos as magnitudes de $\vec{v_{D_1}}$ e $\vec{v_{D_2}}$:

As magnitudes são próximas, indicando que ambos os vetores têm comprimentos similares no espaço vetorial definido pelo vocabulário global.

Embora o produto escalar e as magnitudes sugiram alguma similaridade entre $\vec{v_{D_1}}$ e $\vec{v_{D_2}}$, a leitora pode notar a discrepância em termos de significado semântico.

• $D_1$: “O filme é bom” expressa uma avaliação positiva sobre o filme.
• $D_2$: “O filme não é bom” expressa uma avaliação negativa, ou no mínimo, não positiva, sobre o filme, essencialmente com o sentido oposto ao sentido de $D_1$.

A representação vetorial de frequência, neste caso, falha em capturar essa oposição semântica. Os vetores são considerados similares em termos de produto escalar porque eles compartilham muitas palavras em comum (“o”, “filme”, “é”, “bom”). A presença da palavra “não” em $D_2$, que inverte completamente o sentido, tem um impacto quase insignificante na representação vetorial que usa a técnica de frequência.

Ainda há um aspecto particularmente problemático na representação vetorial por frequência: a questão da dimensionalidade.

Para um vocabulário de tamanho $ \vert V \vert $, cada documento é representado em um espaço $\mathbb{R}^{ \vert V \vert }$. Neste caso, $\mathbb{R}$ refere-se a um espaço vetorial de dimensão $ \vert V \vert $, o tamanho do vocabulário. Isso significa que cada documento é representado como um vetor em um espaço de alta dimensão, no qual cada dimensão corresponde a uma palavra do vocabulário. Para um vocabulário de $10.000$ palavras, cada documento seria representado como um vetor em um espaço de $10.000$ dimensões.

Como usaremos apenas a frequência, teremos vetores extremamente esparsos, nos quais a maioria dos componentes será zero. Esta característica não só é computacionalmente ineficiente, mas também dificulta a identificação de similaridades entre documentos.

Um vetor esparso é um vetor onde a maioria das suas componentes é zero. Em coleções de documentos, como livros, artigos e processos, se usarmos os nossos vetores de frequência, a maioria das palavras do vocabulário não estará presente em um documento específico. Portanto, para um documento $D$, a maioria das entradas em $\vec{v}_D$ será zero.

Trabalhar com vetores em espaços de alta dimensão (milhares, milhões ou bilhões de dimensões) é computacionalmente caro. Armazenar e processar vetores esparsos com tantas dimensões exige recursos significativos de memória e tempo de processamento. Nestas condições, a noção de distância e similaridade torna-se menos intuitiva e, principalmente, menos discriminativa. Vetores esparsos em alta dimensão tendem a ser distantes uns dos outros, mesmo que semanticamente relacionados. Em resumo: vetores esparsos dificultam o cálculo de medidas de similaridade robustas e significativas.

Perda de Informação Contextual

Para verificar a qualidade da representação por frequência e quantificar a perda de informação contextual devido à esparsidade e à alta dimensionalidade, podemos expressar esta perda de informação por meio de uma função de perda $L(\vec{v}_D)$.Podemos definir a função de perda $L(\vec{v}_D)$ como:

Nesta função, temos:

• $L(\vec{v}_D)$: representa a perda de informação contextual ao representar o documento $D$ pelo vetor de frequência $\vec{v}_D$. Idealmente, queremos que $L(\vec{v}_D)$ seja o menor possível, indicando que a representação vetorial preserva o máximo de informação relevante.

• $H(D)$: é a entropia de informação do documento original $D$. A entropia $H(D)$ é uma medida teórica da quantidade total de informação contida no documento $D$. Ela quantifica a incerteza ou aleatoriedade inerente ao documento. Em termos simples, documentos mais complexos e informativos tendem a ter entropia mais alta.

A definição precisa de entropia em contextos textuais pode ser complexa e depender de como a informação é modelada, mas conceitualmente representa a “riqueza” informacional do texto original. A quantidade de termos diferentes que aparecem no documento, a frequência de cada termo e a distribuição de probabilidade dos termos são fatores que influenciam a entropia. Documentos com uma variedade maior de palavras e uma distribuição mais uniforme entre elas tendem a ter maior entropia.

• $I(\vec{v}_D)$: é a informação preservada na representação vetorial $\vec{v}_D$. $I(\vec{v}_D)$ mede quanta informação do documento original $D$ é efetivamente capturada e retida na representação vetorial $\vec{v}_D$. Representações mais eficazes devem maximizar $I(\vec{v}_D)$.

A função $L(\vec{v}_D) = H(D) - I(\vec{v}_D)$ expressa a perda de informação como a diferença entre a informação total original ($H(D)$) e a informação que conseguimos reter na representação vetorial ($\vec{v}_D$).

Para representações como vetores de frequência (e BoW, TF-IDF que veremos a seguir), a perda $L(\vec{v}_D)$ é substancial. Isso ocorre porque, como discutimos, essas representações descartam muita informação contextual importante (ordem das palavras, relações semânticas, nuances, etc.). A entropia original $H(D)$ é alta (o documento contém muita informação), mas a informação preservada $I(\vec{v}_D)$ é relativamente baixa, resultando em uma perda significativa.

A perda de informação $L(\vec{v}_D)$ tende a aumentar com a complexidade semântica do texto. Textos mais complexos, com nuances, ironia, sarcasmo, metáforas, etc., dependem ainda mais do contexto para a compreensão. Representações simples como vetores de frequência falham ainda mais em capturar a riqueza informacional desses textos, resultando em uma perda de informação ainda maior.

A consciência dessas limitações motivou o desenvolvimento de técnicas mais avançadas, como word embeddings (Word2Vec, GloVe, FastText) e modelos de linguagem contextuais (BERT, GPT, Transformers). Vamos chegar lá. Todavia, por enquanto temos que entender algumas outras formas de vetorização que servirão de contextualização e base para o entendimento dos modelos mais avançados.

Bag of Words (BoW)

O modelo Bag of Words (BoW), ou saco de palavras, é uma variação da representação por frequência. O BoW também se baseia na frequência de palavras, mas com uma abordagem que ignora a ordem e a estrutura gramatical das palavras no texto. Este algoritmo trata cada documento como um saco de palavras, onde apenas a presença e a frequência das palavras importam.

O algoritmo Bag of Words (BoW) surgiu da área de recuperação de informação e processamento de linguagem natural. Embora a ideia de representar textos como “sacos de palavras” tenha evoluído ao longo do tempo, um dos trabalhos seminais que formalizou e popularizou essa abordagem é frequentemente creditado a Gerard Salton e seus colaboradores no contexto do sistema SMART (System for the Mechanical Analysis and Retrieval of Text) ³, ⁴.

Para entender o BoW matematicamente, vamos considerar um conjunto de documentos, corpus, $Docs = {D_1, D_2, …, D_N}$. Para construir o BoW, nossa primeira ação será construir um vocabulário global $V_{global}$ que conterá todas as palavras únicas que existem em todos os documentos de $Docs$:

onde $V_{D_i}$ é o vocabulário do documento $D_i$.

Para cada documento $D_i \in Docs$, a representação BoW é um vetor $\vec{bow_{D_i}}$ de tamanho $ \vert V_{global} \vert $. Cada posição $j$ em $\vec{bow_{D_i}}$ corresponde à $j$-ésima palavra $w_j$ em $V_{global}$, e o valor nessa posição será a frequência $f(w_j, D_i)$ da palavra no documento:

Para ilustrar, considere um pequeno corpus com dois documentos:

$D_1$: “O gato preto subiu no telhado” $D_2$: “O cachorro correu no gramado”

O vocabulário global $V_{global}$ será:

Ordenando alfabeticamente (uma prática recomendada para padronização):

Os vetores BoW para cada documento serão:

A atenta leitora deve observar que cada vetor $\vec{bow_{D_i}}$ reside no espaço vetorial inteiro $\mathbb{Z}^{ \vert V_{global} \vert }$. Estes vetores tendem a ser esparsos, ou seja, a maioria de suas componentes é zero, especialmente quando o vocabulário global é grande.

O BoW mantém todas as limitações da representação por frequência de termos que discutimos anteriormente:

1. Perda da ordem das palavras: As frases “João ama Maria” e “Maria ama João” produzem exatamente o mesmo vetor BoW.

2. Ausência de relações semânticas: As frases “O carro é veloz” e “O automóvel é rápido”, embora semanticamente equivalentes, produzem vetores completamente diferentes.

3. Alta dimensionalidade: Para um vocabulário de tamanho $ \vert V_{global} \vert $, cada documento é representado em um espaço $\mathbb{R}^{ \vert V_{global} \vert }$, levando a vetores extremamente esparsos.

A sagaz leitora pode pensar que essas limitações tornam o BoW inútil. Contudo, apesar dessas limitações, o BoW é surpreendentemente eficaz em muitas tarefas de processamento de linguagem natural, especialmente quando combinado com outras técnicas que veremos adiante, como o TF-IDF.

Exemplo 1: usando o C++

#include <iostream>         ///< Para entrada e saída padrão (std::cout, std::cerr).
#include <vector>          ///< Para contêiner std::vector usado no armazenamento de documentos e vocabulário.
#include <string>          ///< Para std::string, usado em palavras e mensagens.
#include <unordered_map>   ///< Para std::unordered_map, usado no mapeamento de palavras para índices.
#include <set>             ///< Para std::set, usado na construção do vocabulário único.
#include <algorithm>       ///< Para std::sort, usado na ordenação do vocabulário.
#include <Eigen/Dense>     ///< Para a biblioteca Eigen, usada em operações de álgebra linear com vetores.
#include <iomanip>         ///< Para std::setw, std::fixed e std::setprecision, usados na formatação de saída.

/**
 * @class BagOfWords
 * @brief Uma classe para implementar o modelo Bag of Words (BoW) para representação de textos.
 *
 * Esta classe converte documentos tokenizados em vetores de frequência de termos (Bag of Words),
 * constrói um vocabulário global, cria uma matriz documento-termo e calcula similaridades entre
 * documentos usando a métrica de similaridade de cosseno. Utiliza a biblioteca Eigen para operações
 * vetoriais.
 */
class BagOfWords {
private:
    std::vector<std::string> vocabulary;              ///< Vocabulário global ordenado alfabeticamente.
    std::unordered_map<std::string, int> wordToIndex; ///< Mapeamento de palavras para índices no vocabulário.
    std::vector<Eigen::VectorXi> documentVectors;     ///< Vetores BoW representando os documentos.

public:
    /**
     * @brief Constrói o vocabulário global a partir de documentos tokenizados.
     * @param documents Vetor de vetores de strings, onde cada vetor interno representa um documento tokenizado.
     */
    void buildVocabulary(const std::vector<std::vector<std::string>>& documents) {
        std::set<std::string> uniqueWords;
        
        // Adicionar todas as palavras ao conjunto de palavras únicas
        for (const auto& doc : documents) {
            for (const auto& word : doc) {
                uniqueWords.insert(word);
            }
        }
        
        // Converter o conjunto para um vetor ordenado
        vocabulary.assign(uniqueWords.begin(), uniqueWords.end());
        std::sort(vocabulary.begin(), vocabulary.end());
        
        // Criar mapeamento de palavras para índices
        for (size_t i = 0; i < vocabulary.size(); ++i) {
            wordToIndex[vocabulary[i]] = i;
        }
    }
    
    /**
     * @brief Cria os vetores BoW para cada documento com base no vocabulário global.
     * @param documents Vetor de vetores de strings, onde cada vetor interno representa um documento tokenizado.
     */
    void createBowVectors(const std::vector<std::vector<std::string>>& documents) {
        documentVectors.clear();
        
        for (const auto& doc : documents) {
            // Inicializar um vetor de zeros com o tamanho do vocabulário
            Eigen::VectorXi bowVector = Eigen::VectorXi::Zero(vocabulary.size());
            
            // Contar a frequência de cada palavra no documento
            for (const auto& word : doc) {
                if (wordToIndex.find(word) != wordToIndex.end()) {
                    int index = wordToIndex[word];
                    bowVector(index)++;
                }
            }
            
            documentVectors.push_back(bowVector);
        }
    }
    
    /**
     * @brief Inicializa o modelo com um conjunto de documentos tokenizados.
     *
     * Constrói o vocabulário global e cria os vetores BoW para os documentos fornecidos.
     * @param documents Vetor de vetores de strings, onde cada vetor interno representa um documento tokenizado.
     */
    void fit(const std::vector<std::vector<std::string>>& documents) {
        buildVocabulary(documents);
        createBowVectors(documents);
    }
    
    /**
     * @brief Obtém o vetor BoW de um novo documento tokenizado.
     * @param document Vetor de strings representando um documento tokenizado.
     * @return Vetor BoW (Eigen::VectorXi) representando as frequências das palavras no documento.
     */
    Eigen::VectorXi transform(const std::vector<std::string>& document) {
        Eigen::VectorXi bowVector = Eigen::VectorXi::Zero(vocabulary.size());
        
        for (const auto& word : document) {
            if (wordToIndex.find(word) != wordToIndex.end()) {
                int index = wordToIndex[word];
                bowVector(index)++;
            }
        }
        
        return bowVector;
    }
    
    /**
     * @brief Calcula a similaridade de cosseno entre dois vetores BoW.
     * @param v1 Primeiro vetor BoW.
     * @param v2 Segundo vetor BoW.
     * @return Valor da similaridade de cosseno (double) entre os vetores, no intervalo [-1, 1].
     */
    double cosineSimilarity(const Eigen::VectorXi& v1, const Eigen::VectorXi& v2) {
        // Converter para double para cálculos de ponto flutuante
        Eigen::VectorXd v1d = v1.cast<double>();
        Eigen::VectorXd v2d = v2.cast<double>();
        
        double dotProduct = v1d.dot(v2d);
        double norm1 = v1d.norm();
        double norm2 = v2d.norm();
        
        if (norm1 < 1e-10 || norm2 < 1e-10) return 0.0;
        return dotProduct / (norm1 * norm2);
    }
    
    /**
     * @brief Imprime a matriz documento-termo (DTM) com formatação.
     */
    void printDocumentTermMatrix() {
        std::cout << "Matriz de Documentos x Termos (Document-Term Matrix):\n\n";
        
        // Imprimir cabeçalho com os termos do vocabulário
        std::cout << std::setw(10) << "Documento";
        for (const auto& word : vocabulary) {
            std::cout << std::setw(10) << word;
        }
        std::cout << "\n";
        
        // Imprimir linha para cada documento
        for (size_t i = 0; i < documentVectors.size(); ++i) {
            std::cout << std::setw(10) << "Doc " + std::to_string(i+1);
            for (int j = 0; j < documentVectors[i].size(); ++j) {
                std::cout << std::setw(10) << documentVectors[i](j);
            }
            std::cout << "\n";
        }
    }
    
    /**
     * @brief Imprime informações sobre o modelo BoW.
     */
    void printInfo() {
        std::cout << "Modelo Bag of Words (BoW)\n";
        std::cout << "-----------------------\n";
        std::cout << "Tamanho do vocabulário: " << vocabulary.size() << " palavras\n";
        std::cout << "Número de documentos: " << documentVectors.size() << "\n\n";
        
        std::cout << "Vocabulário global (ordenado alfabeticamente):\n";
        std::cout << "{ ";
        for (size_t i = 0; i < vocabulary.size(); ++i) {
            std::cout << "\"" << vocabulary[i] << "\"";
            if (i < vocabulary.size() - 1) {
                std::cout << ", ";
            }
        }
        std::cout << " }\n\n";
    }
    
    /**
     * @brief Compara dois documentos com base na similaridade de cosseno.
     * @param doc1Index Índice do primeiro documento.
     * @param doc2Index Índice do segundo documento.
     */
    void compareDocuments(int doc1Index, int doc2Index) {
        if (doc1Index >= documentVectors.size() || doc2Index >= documentVectors.size()) {
            std::cout << "Índice de documento inválido.\n";
            return;
        }
        
        double similarity = cosineSimilarity(documentVectors[doc1Index], 
                                             documentVectors[doc2Index]);
        
        std::cout << "Similaridade entre Doc " << (doc1Index+1) << " e Doc " 
                  << (doc2Index+1) << ": " << std::fixed << std::setprecision(4) 
                  << similarity << "\n";
    }
    
    /**
     * @brief Obtém o vocabulário global.
     * @return Referência constante ao vetor de strings do vocabulário.
     */
    const std::vector<std::string>& getVocabulary() const { return vocabulary; }

    /**
     * @brief Obtém os vetores BoW dos documentos.
     * @return Referência constante ao vetor de vetores BoW.
     */
    const std::vector<Eigen::VectorXi>& getDocumentVectors() const { return documentVectors; }
};

/**
 * @brief Função principal que demonstra o uso do modelo Bag of Words.
 *
 * Este programa cria um modelo BoW a partir de documentos tokenizados, exibe informações sobre
 * o vocabulário e a matriz documento-termo, calcula a similaridade entre documentos, e demonstra
 * a transformação de novos documentos em vetores BoW, incluindo o efeito da ordem das palavras.
 *
 * @return 0 em caso de execução bem-sucedida.
 */
int main() {
    // Documentos já tokenizados para demonstração
    std::vector<std::vector<std::string>> documents = {
        {"o", "gato", "preto", "subiu", "no", "telhado"},
        {"o", "cachorro", "correu", "no", "gramado"}
    };
    
    // Criar e treinar o modelo BoW
    BagOfWords bow; ///< Instância do modelo Bag of Words.
    bow.fit(documents);
    
    // Imprimir informações sobre o modelo
    bow.printInfo();
    
    // Imprimir a matriz de documentos x termos
    bow.printDocumentTermMatrix();
    
    // Calcular similaridade entre os documentos
    std::cout << "\nSimilaridade entre documentos:\n";
    bow.compareDocuments(0, 1);
    
    // Demonstrar o uso do modelo com um novo documento
    std::vector<std::string> newDoc = {"o", "gato", "preto", "desceu", "do", "telhado"};
    std::cout << "\nNovo documento: [\"o\", \"gato\", \"preto\", \"desceu\", \"do\", \"telhado\"]\n";
    
    Eigen::VectorXi newDocVector = bow.transform(newDoc);
    
    // Imprimir o vetor BoW do novo documento
    std::cout << "Vetor BoW do novo documento:\n[ ";
    for (int i = 0; i < newDocVector.size(); ++i) {
        std::cout << newDocVector(i);
        if (i < newDocVector.size() - 1) {
            std::cout << ", ";
        }
    }
    std::cout << " ]\n\n";
    
    // Comparar o novo documento com os existentes
    std::cout << "Similaridade com Doc 1: " << std::fixed << std::setprecision(4) 
              << bow.cosineSimilarity(newDocVector, bow.getDocumentVectors()[0]) << "\n";
    std::cout << "Similaridade com Doc 2: " << std::fixed << std::setprecision(4) 
              << bow.cosineSimilarity(newDocVector, bow.getDocumentVectors()[1]) << "\n";
    
    // Demonstrar como a ordem das palavras não afeta o vetor BoW
    std::vector<std::string> reorderedDoc = {"telhado", "o", "gato", "preto", "subiu", "no"};
    std::cout << "\nDocumento com palavras reordenadas:\n";
    std::cout << "[\"telhado\", \"o\", \"gato\", \"preto\", \"subiu\", \"no\"]\n";
    
    Eigen::VectorXi reorderedVector = bow.transform(reorderedDoc);
    
    std::cout << "Vetor BoW do documento reordenado:\n[ ";
    for (int i = 0; i < reorderedVector.size(); ++i) {
        std::cout << reorderedVector(i);
        if (i < reorderedVector.size() - 1) {
            std::cout << ", ";
        }
    }
    std::cout << " ]\n\n";
    
    // Verificar que os vetores BoW são idênticos, independente da ordem
    bool areEqual = (reorderedVector - bow.getDocumentVectors()[0]).norm() == 0;
    std::cout << "Os vetores BoW do Doc 1 e do documento reordenado são idênticos? "
              << (areEqual ? "Sim" : "Não") << "\n";
    
    return 0;
}

Este exemplo reimplementa o modelo Bag of Words (BoW) assumindo que os documentos são simples, como os que usamos nos exemplos teóricos. A implementação foca exclusivamente na representação matemática e nas funcionalidades essenciais do BoW.

1. Representação matemática pura:

   • A classe BagOfWords implementa diretamente a formulação matemática apresentada no texto:
   • Construção do vocabulário global: $V_{global} = \bigcup_{i=1}^N V_{D_i}$
   • Criação de vetores BoW: $\vec{bow_{D_i}} = [f(w_1, D_i), f(w_2, D_i), …, f(w_{ \vert V_{global} \vert }, D_i)]^T$

2. Uso da biblioteca Eigen:

   • Utilizamos Eigen::VectorXi para representar os vetores de frequência de termos
   • Aproveitamos operações eficientes como .dot() e .norm() para o cálculo de similaridade de cosseno
   • A conversão de tipos de VectorXi para VectorXd é feita através do método .cast<double>()

3. Estruturas de dados eficientes:

   • Usamos std::set para obter palavras únicas ao construir o vocabulário
   • Implementamos um mapeamento eficiente de palavras para índices com std::unordered_map
   • A representação vetorial permite operações matemáticas rápidas nos documentos

4. Demonstração de limitações do BoW:

   • Adicionamos um exemplo específico para mostrar como a ordem das palavras não afeta o vetor BoW
   • Verificamos matematicamente que documentos com palavras em ordens diferentes produzem vetores idênticos

No código do exemplo, implementamos as seguintes funções principais:

• buildVocabulary(): constrói o vocabulário global ordenado alfabeticamente
• createBowVectors(): cria os vetores de frequência de termos para cada documento
• transform(): converte um novo documento em um vetor BoW usando o vocabulário existente
• cosineSimilarity(): calcula a similaridade entre dois documentos, usando a fórmula:

• printDocumentTermMatrix(): Visualiza a matriz de documentos por termos

Por fim, na função main():

1. usamos os documentos do exemplo no texto: “O gato preto subiu no telhado” e “O cachorro correu no gramado”;
2. construímos o modelo BoW e visualizamos a matriz de documentos por termos;
3. calculamos a similaridade entre os documentos;
4. demonstramos a aplicação do modelo a um novo documento;
5. ilustramos de forma prática uma das limitações fundamentais do BoW: a perda da ordem das palavras.

Esta implementação é concisa e focada nos aspectos matemáticos do BoW. Com o único objetivo de permitir que a esforçada leitora possa entender como passar a matemática para código em C++.

Caberá a criativa leitora a criar sua própria interpretação.

TF-IDF (Term Frequency-Inverse Document Frequency)

O TF-IDF (Term Frequency-Inverse Document Frequency) tem origem nos trabalhos de Spärck⁵ e Salton⁶ quase como uma evolução natural do modelo BoW com o objetivo de resolver um dos seus problemas fundamentais: a dominância de palavras muito frequentes. O TF-IDF teve impacto significativo na área de recuperação de informação por conseguir ponderar a importância das palavras levando em consideração, além da frequência em um determinado documento, a raridade no corpus.

Formalmente, seja $Docs = {D_1, D_2, …, D_N}$ um corpus com $N$ documentos. O TF-IDF combinará duas métricas complementares para cada palavra $w$ em um documento $D_i$. Da seguinte forma:

1. Term Frequency (TF): captura a importância local da palavra no documento;
2. Inverse Document Frequency (IDF): mede a importância global da palavra no corpus.

Uma forma interessante de entender o TF-IDF é dividir o algoritmo em suas partes constituintes e entender cada parte em separado. Dividir para vencer!

Term Frequency (TF)

O cálculo da frequência de termos, ou Term Frequency (TF), pode ser realizado de diferentes formas, cada uma com suas próprias características e aplicações.

A forma mais simples de calcular o TF é usar a frequência bruta, $raw$, também chamada de contagem absoluta:

Nesta definição, $f(w, D_i)$ representa o número de vezes que a palavra $w$ aparece no documento $D_i$.

Exemplo 1: considere os dois documentos $D_1$ e $D_2$, a seguir:

• $D_1$: “O pequeno gato preto viu outro gato preto”;
• $D_2$: “Gato”.

Para a palavra “gato”, teríamos:

• $\text{TF_{raw}}(\text{“gato”}, D_1) = 2$;
• $\text{TF_{raw}}(\text{“gato”}, D_2) = 1$.

A frequência bruta, embora simples, apresenta um problema: ela não considera o tamanho do documento. No exemplo 1 acima, “gato” representa $100\%$ das palavras em $D_2$, mas apenas $25\%$ das palavras em $D_1$. A frequência bruta não consegue capturar essa diferença de importância relativa.

A frequência bruta pode ser enganosa, especialmente quando comparamos documentos de tamanhos diferentes. Em um documento pequeno, uma palavra pode ter uma frequência bruta alta, mas isso não significa que ela seja mais importante do que em um documento maior.

Exemplo 2: vamos tentar novamente usando um corpus com três documentos. Considere:

• $D_1$: “O gato preto caça o rato preto”;
• $D_2$: “O rato branco corre do gato”;
• $D_3$: “O cachorro late para o gato preto”.

Para este corpus, teremos:

Para a palavra “gato”:

• $\text{TF_{raw}}(\text{“gato”}, D_1) = 1$
• $\text{TF_{raw}}(\text{“gato”}, D_2) = 1$
• $\text{TF_{raw}}(\text{“gato”}, D_3) = 1$

Para a palavra “preto”:

• $\text{TF_{raw}}(\text{“preto”}, D_1) = 2$
• $\text{TF_{raw}}(\text{“preto”}, D_2) = 0$
• $\text{TF_{raw}}(\text{“preto”}, D_3) = 1$

Para resolver a limitação da frequência bruta, utilizamos a frequência normalizada que pode ser definida como:

O denominador $\sum_{w’ \in D_i} f(w’, D_i)$ representa o número total de palavras no documento $D_i$.

Exemplo 3: novamente considere o corpus dado por:

$D_1$: “O pequeno gato preto viu outro gato preto”; $D_2$: “Gato”.

Para a palavra “gato”, teríamos:

Para $D_1$: “O pequeno gato preto viu outro gato preto” (8 palavras total)

• $f(\text{“gato”}, D_1) = 2$;
• $\sum_{w’ \in D_1} f(w’, D_1) = 8$;
• $\text{TF}(\text{“gato”}, D_1) = \frac{2}{8} = 0.25$.

Para $D_2$: “Gato” (1 palavra total)

• $f(\text{“gato”}, D_2) = 1$;
• $\sum_{w’ \in D_2} f(w’, D_1) = 1$;
• $\text{TF}(\text{“gato”}, D_2) = \frac{1}{1} = 1.0$.

A sagaz leitora pode ver que a frequência normalizada captura melhor a importância relativa da palavra em cada documento. Em $D_2$, “gato” tem frequência normalizada $1.0$, indicando que representa $100\%$ do documento, enquanto em $D_1$ tem frequência $0.25$, representando $25\%$ do documento.

Exemplo 4: voltando ao corpus com três documentos, teríamos:

Para $D_1$ (8 palavras total):

Para $D_2$ (7 palavras total):

Para $D_3$ (7 palavras total):

Além das frequências bruta e normalizada, existem outras formulações importantes do TF, criadas para resolver problemas específicos na representação de documentos.

Frequência Logarítmica

A frequência logarítmica é definida como:

Esta formulação é útil quando temos palavras com frequências muito diferentes em um mesmo documento. O logaritmo ajuda a comprimir essas diferenças, evitando que palavras muito frequentes dominem completamente a representação.

Exemplo 5: considere o documento:

$D_1$: “O cachorro late. O cachorro corre. O cachorro pula. O gato dorme.”

Calculando TF para as palavras “cachorro” e “gato”, teremos:

• $f(\text{“cachorro”}, D_1) = 3$;
• $f(\text{“gato”}, D_1) = 1$.

Com frequência bruta, a diferença é $3:1$

• $\text{TF_{raw}}(\text{“cachorro”}, D_1) = 3$;
• $\text{TF_{raw}}(\text{“gato”}, D_1) = 1$.

Com frequência logarítmica, a diferença é menor:

• $\text{log}(\text{“cachorro”}, D_1) = 1 + \log(3) \approx 1.48$;
• $\text{log}(\text{“gato”}, D_1) = 1 + \log(1) = 1$.

A frequência logarítmica reduz a razão de $3:1$ para aproximadamente $1.48:1$, suavizando a dominância de “cachorro”. A redução da razão de $3:1$ para $1.48:1$ através da transformação logarítmica é matematicamente significativa porque reflete melhor como os humanos processam informação linguística. Uma palavra que aparece $3$ vezes em um texto não é necessariamente $3$ vezes mais importante para o significado do documento do que uma palavra que aparece apenas uma vez.

Exemplo 6: voltando ao corpus de três documentos, teremos:

• $D_1$: “O gato preto caça o rato preto”;
• $D_2$: “O rato branco corre do gato”;
• $D_3$: “O cachorro late para o gato preto”.

Para “preto” em $D_1$:

Para “gato” em $D_2$:

Esta propriedade de compressão do logaritmo é particularmente valiosa em processamento de linguagem natural porque segue a Lei de Weber-Fechner, que estabelece que a percepção humana de diferenças tende a ser logarítmica em relação ao estímulo real: da mesma forma que não percebemos uma luz com $300$ lumens como sendo 3 vezes mais brilhante que uma com $100$ lumens, também não interpretamos uma palavra que aparece $3$ vezes em um texto como tendo o triplo da importância semântica de uma palavra que aparece uma única vez.

A propriedade de compressão logarítmica, frequentemente utilizada em processamento de linguagem natural, encontra justificativa na Lei de Weber-Fechner. Esta lei psicofísica fundamental descreve a relação entre a magnitude física de um estímulo e a percepção humana da intensidade desse estímulo.

Em essência, a Lei de Weber-Fechner postula que a percepção sensorial é proporcional ao logaritmo da intensidade real do estímulo. Matematicamente, isso pode ser expresso como:

\[P = k \cdot \log(S/S_0)\]

Na qual, temos:

• $P$ representa a magnitude da percepção.
• $S$ é a intensidade do estímulo.
• $S_0$ é o limiar de detecção do estímulo (o menor estímulo>que pode ser percebido).
• $k$ é uma constante de proporcionalidade, dependente do tipo de estímulo e da modalidade sensorial.

A Lei de Weber-Fechner implica que a nossa percepção de mudanças em estímulos não é linear, mas sim logarítmica. Em vez de percebermos aumentos aritméticos na intensidade de um estímulo como aumentos lineares na percepção, percebemos aumentos geométricos como aumentos aritméticos.

No contexto do processamento de linguagem natural e, especificamente, no algoritmo TF-IDF, essa lei se torna relevante ao justificar a aplicação do logaritmo na frequência dos termos (TF) e na frequência inversa nos documentos (IDF). Assim como a percepção humana não escala linearmente com a intensidade da luz, também não interpretamos a importância de uma palavra em um texto de forma linear com sua frequência bruta.

Por exemplo, uma luz com $300$ lumens não será percebida como três vezes mais brilhante que uma com $100$ lumens. De forma análoga, uma palavra que aparece $3$ vezes em um documento não será necessariamente considerada três vezes mais importante semanticamente do que uma palavra que aparece apenas uma vez. A aplicação do logaritmo na frequência dos termos e documentos no TF-IDF busca modelar essa percepção humana não linear da importância, dando menos peso a aumentos lineares na frequência e enfatizando a presença da palavra, mesmo que não seja extremamente frequente.

Embora o trabalho de Weber[^9] tenha dado início a pequisas que levou a Lei Weber-Fechner. Gustav Theodor Fechner expandiu e formalizou as ideias de Ernst Heinrich Weber em sua obra posterior⁷. A formulação matemática mais completa e a denominação da lei são geralmente atribuídas a Fechner.

Este princípio psicofísico, portanto, oferece uma base teórica para a utilização da compressão logarítmica em técnicas de processamento de linguagem natural como TF-IDF, alinhando o processamento computacional de texto com a forma como os humanos percebem e interpretam a informação.

[^9]WEBER, E. H. De tactu: Annotationes anatomicae et physiologicae. Lipsiae: Koehler, 1834.

Frequência Binária

A frequência binária simplifica a representação para apenas presença ou ausência:

Esta formulação é útil quando a presença de uma palavra é mais importante que sua frequência. Por exemplo, quando estamos interessados na classificação de textos por tópicos ou na análise de palavras-chave.

Exemplo 7: para que a amável leitora entenda, considere dois documentos:

• $D_1$: “Python é uma linguagem de programação. Python é versátil. Python é popular”;
• $D_2$: “Java é uma linguagem de programação”.

Se calcularmos TF a palavra “linguagem”, teremos:

• $\text{TF_{raw}}(\text{“linguagem”}, D_1) = 1$;
• $\text{TF_{raw}}(\text{“linguagem”}, D_2) = 1$;
• $\text{TF_{binary}}(\text{“linguagem”}, D_1) = 1$;
• $\text{TF_{binary}}(\text{“linguagem”}, D_2) = 1$.

Para a palavra “Python”:

• $\text{TF_{raw}}(\text{“Python”}, D_1) = 3$;
• $\text{TF_{raw}}(\text{“Python”}, D_2) = 0$;
• $\text{TF_{binary}}(\text{“Python”}, D_1) = 1$;
• $\text{TF_{binary}}(\text{“Python”}, D_2) = 0$.

A frequência binária indica apenas que $D_1$ é sobre Python e $D_2$ não é, ignorando a repetição da palavra.

Exemplo 8: podemos aplicar a frequência binária ao corpus com três documentos que usamos anteriormente:

$D_1$: “O gato preto caça o rato preto”; $D_2$: “O rato branco corre do gato”; $D_3$: “O cachorro late para o gato preto”.

Para “rato”:

• $\text{TF_{binary}}(\text{“rato”}, D_1) = 1$ (presente);
• $\text{TF_{binary}}(\text{“rato”}, D_2) = 1$ (presente);
• $\text{TF_{binary}}(\text{“rato”}, D_3) = 0$ (ausente).

Frequência Aumentada (Augmented Frequency)

A frequência aumentada é definida como:

Nesta fórmula temos:

• $f(w, D_i)$ é a frequência bruta do termo $w$ no documento $D_i$;
• $max_{w’ ∈ D_i} f(w’, D_i)$ é a frequência do termo mais frequente em $D_i$;
• $0,5$ é um fator de amortecimento que impede que termos que aparecem muitas vezes dominem completamente a ponderação.

Usamos esta fórmula quando queremos considerar a frequência relativa das palavras, mas evitar que documentos longos dominem apenas por seu tamanho. O termo $0.5$ garante um peso mínimo para qualquer palavra presente.

Exemplo 9: considere o documento: $D_1$: “O gato preto viu outro gato preto. O gato dormiu.”

Para este documento:

• $f(\text{“gato”}, D_1) = 3$ (palavra mais frequente);
• $f(\text{“preto”}, D_1) = 2$;
• $f(\text{“dormiu”}, D_1) = 1$.

Calculando $\text{aug}$:

• $\text{aug}(\text{“gato”}, D_1) = 0.5 + 0.5 \times \frac{3}{3} = 1.0$;
• $\text{aug}(\text{“preto”}, D_1) = 0.5 + 0.5 \times \frac{2}{3} \approx 0.83$;
• $\text{aug}(\text{“dormiu”}, D_1) = 0.5 + 0.5 \times \frac{1}{3} \approx 0.67$.

Observe que mesmo “dormiu”, que aparece apenas uma vez, recebe um peso considerável $(0.67)$ devido ao termo base $0.5$.

Exemplo 10: usando o corpus com três documentos:

• $D_1$: “O gato preto caça o rato preto”;
• $D_2$: “O rato branco corre do gato”;
• $D_3$: “O cachorro late para o gato preto”.

Para $D_1$, a palavra mais frequente aparece 2 vezes (“preto”):

Para “gato”:

Para “preto”:

A frequência aumentada se destaca sistemas de recuperação de informação e mecanismos de busca onde temos documentos de tamanhos muito diferentes, como por exemplo, ao comparar artigos científicos com resumos ou abstracts.

Ao utilizar a fórmula da frequência aumentada, garantimos que mesmo palavras que aparecem apenas uma vez ainda recebam um peso mínimo de $0.5$, enquanto a palavra mais frequente no documento recebe peso $1.0$, criando assim uma distribuição mais equilibrada que é valiosa quando precisamos comparar documentos de diferentes comprimentos ou quando queremos evitar que documentos longos dominem os resultados graças ao seu tamanho. Um problema comum em sistemas de busca acadêmica, bibliotecas digitais e bases de dados documentais, onde a variação no tamanho dos documentos pode ser significativa.

Além das quatro formas que estudamos ($\text{raw}$, $\text{log}$, $\text{binary}$ e $\text{aug}$), existem várias outras formulações para o cálculo do TF. Uma variação particularmente interessante é a frequência $K$-modificada, definida como:

Na qual, teremos:

• $K$ é um parâmetro ajustável no intervalo $[0,1]$;
• $f(w, D_i)\;$ é a frequência bruta do termo $w$ no documento $D_i$;
• $\max_{w’ \in D_i} f(w’, D_i)\;$ é a frequência bruta máxima de qualquer termo em $D_i$;
• $(1-K)$ serve como um fator de escala para a normalização da frequência do termo;

Observe que esta fórmula é uma generalização da frequência aumentada, que é um caso especial onde $K = 0.5$. Outra variação importante é a frequência logarítmica suavizada:

que aplica uma dupla transformação logarítmica para uma suavização ainda mais agressiva. Também existe a frequência normalizada por comprimento:

que usa a norma euclidiana do documento como fator de normalização, sendo particularmente útil quando trabalhamos com vetores em espaços de alta dimensão. A escolha entre estas diferentes formulações geralmente depende do domínio específico e das características do corpus, sendo comum em sistemas modernos o uso de várias formulações em conjunto, combinadas através de técnicas de ensemble ou votação ponderada.

Técnicas de ensemble e votação ponderada são métodos de combinação de diferentes abordagens para obter resultados mais robustos e confiáveis. Imagine um grupo de especialistas médicos analisando um caso complexo. Cada um tem sua expertise e perspectiva única, e a decisão final considera a opinião de todos, dando mais peso aos especialistas com mais experiência em aspectos específicos do caso. No contexto do TF-IDF, estas técnicas funcionam de forma similar: diferentes fórmulas de TF são calculadas para o mesmo texto (como $\text{log}$, $\text{aug}$, etc.), e o resultado final é uma combinação ponderada desses valores. Por exemplo, podemos dar mais peso ao $\text{aug}$ quando trabalhamos com documentos de tamanhos muito diferentes, e mais peso ao $\text{log}$ quando lidamos com palavras de frequências muito variadas. Esta abordagem é particularmente poderosa porque combina as vantagens de diferentes formulações, compensando as limitações individuais de cada método e produzindo resultados mais estáveis e precisos em uma variedade maior de situações.

Quase deixo passar! A palavra ensemble vem do francês e significa conjunto, ou em conjunto. No contexto de análise de dados e aprendizado de máquina, uma técnica de ensemble refere-se a um método que combina múltiplos modelos ou abordagens diferentes para criar uma solução mais robusta. Como uma orquestra que, não por coincidência, também usa a palavra ensemble.

Em uma orquestra cada instrumento contribui com seu som único, e juntos criam uma música mais rica e complexa do que qualquer instrumento sozinho poderia produzir. Da mesma forma, quando falamos de ensemble no contexto do TF-IDF, estamos falando de combinar diferentes fórmulas de cálculo do TF ou do IDF, cada uma com suas características específicas, para obter um resultado mais preciso e confiável.

Escolhendo a Formulação Adequada

No momento de definir sua aplicação, a analítica leitora deve considerar:

1. Natureza dos Documentos:

   • Documentos longos → Frequência normalizada ou aumentada;
   • Documentos curtos → Frequência bruta pode ser adequada.

2. Objetivo da Análise:

   • Classificação de tópicos → Frequência binária;
   • Recuperação de informação → Frequência logarítmica;
   • Análise de similaridade → Frequência aumentada.

3. Características do Vocabulário:

   • Palavras com frequências muito diferentes → Frequência logarítmica;
   • Palavras-chave importantes → Frequência binária ou aumentada.

A esforçada leitora deverá experimentar diferentes formulações em seu conjunto de dados específico, avaliando o impacto de cada uma no desempenho final do seu sistema. Triste é a sina daquela que pesquisa e aprende.

Um pouco de código em C++ deve ajudar a amável leitora a entender melhor o conceito de TF. O código tenta seguir as fórmulas matemáticas apresentadas no texto, demonstrando como traduzir expressões matemáticas para código C++.

Não deixe de notar que a implementação está simplificada e não considera tarefas de pré-processamento como tokenização, remoção de stopwords ou stemming, que seriam importantes em aplicações reais e que serão discutidos em detalhes mais adiante.

O código a seguir utiliza a biblioteca Eigen, utilizada em aplicações científicas e de aprendizado de máquina. A biblioteca é leve e fácil de usar, permitindo operações eficientes com matrizes e vetores em alto desempenho e com precisão numérica.

#include <iostream>         ///< Para entrada e saída padrão (std::cout).
#include <vector>          ///< Para contêiner std::vector usado no armazenamento de documentos.
#include <string>          ///< Para std::string, usado em palavras e mensagens.
#include <unordered_map>   ///< Para std::unordered_map, usado no cálculo de contagens de termos.
#include <cmath>           ///< Para std::log, usado na frequência logarítmica.
#include <Eigen/Dense>     ///< Para a biblioteca Eigen (não utilizada diretamente neste código).
#include <algorithm>       ///< Para std::max, usado no cálculo da frequência aumentada.

/**
 * @class TermFrequency
 * @brief Uma classe para calcular diferentes métricas de frequência de termos (TF) em documentos.
 *
 * Esta classe oferece métodos estáticos para calcular a frequência bruta, normalizada, logarítmica,
 * binária e aumentada de um termo em um documento tokenizado.
 */
class TermFrequency {
public:
    /**
     * @brief Calcula a frequência bruta (raw) de um termo em um documento.
     * @param document Vetor de strings representando o documento tokenizado.
     * @param term O termo cuja frequência será calculada.
     * @return O número de ocorrências do termo no documento (double).
     */
    static double raw(const std::vector<std::string>& document, const std::string& term) {
        double count = 0;
        for (const auto& word : document) {
            if (word == term) {
                count++;
            }
        }
        return count;
    }
    
    /**
     * @brief Calcula a frequência normalizada de um termo em um documento.
     * @param document Vetor de strings representando o documento tokenizado.
     * @param term O termo cuja frequência será calculada.
     * @return A frequência bruta dividida pelo tamanho do documento (double).
     */
    static double normalized(const std::vector<std::string>& document, const std::string& term) {
        double count = raw(document, term);
        return count / document.size();
    }
    
    /**
     * @brief Calcula a frequência logarítmica de um termo em um documento.
     * @param document Vetor de strings representando o documento tokenizado.
     * @param term O termo cuja frequência será calculada.
     * @return 1 + log(frequência bruta) se a frequência for maior que 0, caso contrário 0 (double).
     */
    static double logarithmic(const std::vector<std::string>& document, const std::string& term) {
        double count = raw(document, term);
        return count > 0 ? 1.0 + std::log(count) : 0.0;
    }
    
    /**
     * @brief Calcula a frequência binária de um termo em um documento.
     * @param document Vetor de strings representando o documento tokenizado.
     * @param term O termo cuja frequência será calculada.
     * @return 1.0 se o termo está presente no documento, 0.0 caso contrário (double).
     */
    static double binary(const std::vector<std::string>& document, const std::string& term) {
        for (const auto& word : document) {
            if (word == term) {
                return 1.0;
            }
        }
        return 0.0;
    }
    
    /**
     * @brief Calcula a frequência aumentada (augmented) de um termo em um documento.
     * @param document Vetor de strings representando o documento tokenizado.
     * @param term O termo cuja frequência será calculada.
     * @return 0.5 + 0.5 * (frequência bruta do termo / frequência máxima de qualquer termo) (double).
     */
    static double augmented(const std::vector<std::string>& document, const std::string& term) {
        std::unordered_map<std::string, int> termCounts;
        
        // Contar ocorrências de cada termo
        for (const auto& word : document) {
            termCounts[word]++;
        }
        
        // Encontrar o termo mais frequente
        int maxCount = 0;
        for (const auto& [_, count] : termCounts) {
            maxCount = std::max(maxCount, count);
        }
        
        int termCount = termCounts[term];
        return 0.5 + 0.5 * (static_cast<double>(termCount) / maxCount);
    }
};

/**
 * @brief Função principal que demonstra o uso da classe TermFrequency.
 *
 * Este programa calcula e exibe diferentes métricas de frequência de termos (TF) para o termo "gato"
 * em dois documentos tokenizados, utilizando os métodos da classe TermFrequency.
 *
 * @return 0 em caso de execução bem-sucedida.
 */
int main() {
    // Documentos tokenizados para demonstração
    std::vector<std::string> doc1 = {"o", "pequeno", "gato", "preto", "viu", "outro", "gato", "preto"}; ///< Primeiro documento.
    std::vector<std::string> doc2 = {"gato"}; ///< Segundo documento.
    
    std::string term = "gato"; ///< Termo a ser analisado.
    
    std::cout << "Para o termo '" << term << "':\n";
    
    std::cout << "Documento 1:\n";
    std::cout << "  TF_raw: " << TermFrequency::raw(doc1, term) << "\n";
    std::cout << "  TF_normalized: " << TermFrequency::normalized(doc1, term) << "\n";
    std::cout << "  TF_logarithmic: " << TermFrequency::logarithmic(doc1, term) << "\n";
    std::cout << "  TF_binary: " << TermFrequency::binary(doc1, term) << "\n";
    std::cout << "  TF_augmented: " << TermFrequency::augmented(doc1, term) << "\n";
    
    std::cout << "Documento 2:\n";
    std::cout << "  TF_raw: " << TermFrequency::raw(doc2, term) << "\n";
    std::cout << "  TF_normalized: " << TermFrequency::normalized(doc2, term) << "\n";
    std::cout << "  TF_logarithmic: " << TermFrequency::logarithmic(doc2, term) << "\n";
    std::cout << "  TF_binary: " << TermFrequency::binary(doc2, term) << "\n";
    std::cout << "  TF_augmented: " << TermFrequency::augmented(doc2, term) << "\n";
    
    return 0;
}

Inverse Document Frequency (IDF)

A Frequência Inversa nos Documentos (IDF, do inglês Inverse Document Frequency) foi necessária para criar um nível de refinamento para a medida de frequência de termos (TF). Enquanto o TF quantifica a importância de um termo dentro de um documento específico, ele não considera a distribuição desse termo em uma determinada coleção de documentos.

A ideia que sustenta a criação do IDF é que termos que aparecem frequentemente em todos os documentos de uma coleção são menos relevantes para distinguir documentos uns dos outros. Termos como “o”, “e”, “de”, por exemplo, são muito comuns na maioria dos textos em português, mas raramente carregam um peso semântico suficientemente significativo na diferenciação entre dois documento. Atribuir alta importância a essas palavras com base apenas em sua frequência dentro de um documento, TF, pode levar a resultados de busca e análise de texto aquém do esperado para uma função específica.

O conceito de IDF foi introduzido por Karen Spärck Jones em seu artigo seminal de 1972, intitulado A statistical interpretation of term specificity and its application in retrieval⁸. Neste trabalho, Spärck Jones argumentou que a especificidade de um termo, ou seja, quão distintivo ele é dentro de uma coleção de documentos, deveria ser levada em conta para melhorar a recuperação de informação. O IDF é uma medida dessa especificidade.

O cálculo do IDF é definido pela seguinte fórmula:

Na qual, temos:

• $ \vert Docs \vert $ representa o número total de documentos na coleção;
• $ \vert {D_j \in Docs: w \in D_j} \vert $ é o número de documentos que contêm a palavra $w$. Este valor representa a frequência documental da palavra $w$;
• $\log$ é o logaritmo natural (base $e$).

Exemplo 1: considere o corpus com três documentos que temos usado:

$D_1$: “O gato preto caça o rato preto” $D_2$: “O rato branco corre do gato” $D_3$: “O cachorro late para o gato preto”

Para “gato” (aparece nos 3 documentos):

Para “preto” (aparece em 2 documentos):

Para “cachorro” (aparece em 1 documento):

A função logarítmica na fórmula do IDF desempenha dois papéis importantes que precisamos destacar:

1. Suavização da divisão: a aplicação do logaritmo atenua o impacto de grandes variações no denominador. Isso é particularmente útil quando se lida com coleções de documentos muito grandes, onde a frequência documental de alguns termos pode ser muito baixa, levando a valores de IDF muito altos sem a suavização logarítmica.

2. Garantia de baixo peso para palavras comuns: a função logarítmica garante que palavras muito comuns, que aparecem em um grande número de documentos (fazendo com que o denominador $ \vert {D_j \in Docs: w \in D_j} \vert $ se aproxime de $ \vert Docs \vert $), resultem em valores de IDF próximos de zero. Idealmente, se uma palavra aparece em todos os documentos, o termo dentro do logaritmo se torna 1, e $\log(1) = 0$, atribuindo um IDF nulo a essa palavra, indicando sua falta de poder discriminatório.

Em resumo, o IDF atua como um fator de ponderação que diminui a importância de termos que são comuns em muitos documentos e aumenta a importância de termos que são raros e, portanto, mais específicos e discriminativos dentro da coleção. Ao combinar o IDF com o TF, o algoritmo TF-IDF consegue identificar termos que são importantes em um documento específico e, ao mesmo tempo, distintivos em relação à coleção de documentos como um todo, melhorando significativamente a eficácia em tarefas como recuperação de informação e análise de texto.

Existem diferentes versões da fórmula IDF. Embora o princípio básico permaneça o mesmo, reduzir o peso de termos que aparecem frequentemente em toda a coleção de documentos, existem variações para abordar nuances específicas ou melhorar o desempenho em certos cenários. Aqui está uma análise de algumas versões comuns de IDF:

IDF Básico (conforme descrito anteriormente)

Esta é a versão mais fundamental e amplamente utilizada, frequentemente referida como IDF padrão.

Exemplo 2: voltando ao corpus com três documentos:

$D_1$: “O gato preto caça o rato preto” $D_2$: “O rato branco corre do gato” $D_3$: “O cachorro late para o gato preto”

Para “gato” (aparece nos 3 documentos):

Para “preto” (aparece em 2 documentos):

Para “cachorro” (aparece em 1 documento):

Esta é uma versão simples de entender e implementar, funciona bem em muitos casos gerais. Todavia, pode ser instável quando um termo não aparece em nenhum documento da coleção. Neste caso, o denominador torna-se zero, levando à divisão por zero. Além disso, não leva em conta a frequência do termo nos documentos onde ele aparece, apenas a contagem de documentos.

IDF com Suavização (IDF+1)

Para evitar a divisão por zero quando um termo não está presente em nenhum documento e para atenuar ligeiramente o efeito IDF para termos muito raros, um fator de suavização é frequentemente adicionado ao denominador. Uma abordagem comum é adicionar $1$ à contagem da frequência documental resultando em:

Exemplo 3: novamente com o corpus de três documentos:

$D_1$: “O gato preto caça o rato preto” $D_2$: “O rato branco corre do gato” $D_3$: “O cachorro late para o gato preto”

Para “gato” (aparece nos 3 documentos):

Para “preto” (aparece em 2 documentos):

Para “cachorro” (aparece em 1 documento):

Esta fórmula impede a divisão por zero, fornece um valor IDF não nulo mesmo para termos não presentes na coleção e reduz ligeiramente o impacto de termos muito raros. Trata-se de uma formulação mais estável numericamente do que o IDF básico. Esta fórmula também não considera a frequência do termo dentro dos documentos.

IDF Probabilístico

Esta versão visa estimar a probabilidade de um documento ser relevante dado um termo⁹, e vice-versa. Uma fórmula IDF probabilística comum é:

Ou, por vezes, vista como:

Nesta fórmula, $N = \vert Docs \vert $ e $df_w = \vert {D_j \in Docs: w \in D_j} \vert $, frequência documental da palavra $w$.

Exemplo 4: usando o corpus de três documentos:

• $D_1$: “O gato preto caça o rato preto”;
• $D_2$: “O rato branco corre do gato”;
• $D_3$: “O cachorro late para o gato preto”.

Para “gato”:

(Indefinido, mostrando uma limitação desta formulação)

Para “preto”:

O IDF probabilístico com sua interpretação probabilística, potencialmente reflete melhor o caráter informativo de termos raros em alguns cenários. Contudo, pode resultar em valores IDF negativos se o termo aparecer em mais de metade dos documentos, o que pode não ser intuitivo. Além disso, o IDF probabilístico é sensível à frequência documental.

IDF Máximo

Esta variação define um limite superior para o valor IDF. Baseia-se na ideia de que, após um certo ponto, aumentar os valores IDF para termos extremamente raros pode não ser benéfico e pode até ser prejudicial. Uma abordagem é usar o valor IDF máximo observado na coleção como o limite prático da sua aplicação:

Neste caso, $\text{IDF}(w, Docs)$ é tipicamente o IDF básico ou IDF+1.

O IDF Máximo, ou IDF Max, limita a influência de termos extremamente raros, melhorando potencialmente a robustez e prevenindo o overfitting a ruído nos dados. Porém, introduz um corte relativamente arbitrário, o que pode ser prejudicial em alguns conjuntos de dados.

IDF Normalizado por Comprimento (Length-Normalized IDF)

Em alguns casos, o comprimento do documento pode influenciar a frequência do termo e a frequência documental. Documentos mais longos têm maior probabilidade de conter qualquer termo dado, potencialmente inflando as frequências documentais para termos comuns. A normalização por comprimento pode ser aplicada também ao IDF, embora seja menos comum do que a normalização por comprimento para TF. Uma abordagem é normalizar a frequência documental pelo comprimento médio do documento:

Esta versão é menos formalmente definida e mais um conceito. Geralmente envolveria o ajuste da contagem da frequência documental com base no comprimento do documento, mas as fórmulas específicas variam.

• Prós: Potencialmente mitiga o efeito do viés do comprimento do documento nos valores IDF;
• Contras: Adiciona complexidade, e o benefício pode ser marginal em comparação com a normalização por comprimento aplicada ao TF.

Escolhendo a versão IDF

A esforçada leitora terá alguma dificuldade de encontrar a versão do IDF adequada ao seu projeto. Isso irá requerer empiricismo e paciência. Contudo, para a recuperação de texto de propósito geral, o IDF básico ou IDF+1 são frequentemente suficientes e fornecem um bom equilíbrio entre simplicidade e eficácia. Da mesma forma, o IDF probabilístico deve ser considerado quando uma interpretação probabilística é desejada, ou quando se lida com conjuntos de dados nos quais se espera que termos raros sejam altamente informativos.

Finalmente, considere que o IDF máximo pode ser útil em cenários onde a robustez a outliers e termos extremamente raros seja importante e o IDF normalizado por comprimento, embora seja menos comum, pode ser avaliado se, durante os seus testes, o comprimento do documento for suspeito de ser um fator de confusão significativo.

Novamente, para que a esforçada leitora não se perca na matemática pura, um pouco de código em C++ pode ajudar.

#include <iostream>         ///< Para entrada e saída padrão (std::cout).
#include <vector>          ///< Para contêiner std::vector usado no armazenamento de corpus e termos.
#include <string>          ///< Para std::string, usado em palavras e mensagens.
#include <unordered_map>   ///< Para std::unordered_map (não utilizado diretamente neste código).
#include <unordered_set>   ///< Para std::unordered_set, usado para identificar termos únicos em documentos.
#include <cmath>           ///< Para std::log, usado nos cálculos de IDF.
#include <Eigen/Dense>     ///< Para a biblioteca Eigen (não utilizada diretamente neste código).

/**
 * @class InverseDocumentFrequency
 * @brief Uma classe para calcular diferentes métricas de frequência inversa de documentos (IDF) em um corpus.
 *
 * Esta classe oferece métodos estáticos para calcular o IDF básico, suavizado e probabilístico de um termo
 * em um corpus de documentos tokenizados, além de um método para exibir todas as variantes para um conjunto de termos.
 */
class InverseDocumentFrequency {
public:
    /**
     * @brief Calcula o IDF básico de um termo em um corpus.
     * @param corpus Vetor de vetores de strings, onde cada vetor interno representa um documento tokenizado.
     * @param term O termo cuja IDF será calculada.
     * @return O valor do IDF básico, dado por log(N / df), onde N é o número de documentos e df é a frequência documental (double).
     */
    static double basic(const std::vector<std::vector<std::string>>& corpus, const std::string& term) {
        double N = corpus.size(); // número total de documentos
        double df = 0;           // document frequency
        
        for (const auto& document : corpus) {
            for (const auto& word : document) {
                if (word == term) {
                    df++;
                    break; // contamos o documento apenas uma vez
                }
            }
        }
        
        // Evitar divisão por zero
        if (df == 0) return 0.0;
        
        return std::log(N / df);
    }
    
    /**
     * @brief Calcula o IDF com suavização (IDF+1) de um termo em um corpus.
     * @param corpus Vetor de vetores de strings, onde cada vetor interno representa um documento tokenizado.
     * @param term O termo cuja IDF será calculada.
     * @return O valor do IDF suavizado, dado por log(N / (1 + df)), onde N é o número de documentos e df é a frequência documental (double).
     */
    static double smooth(const std::vector<std::vector<std::string>>& corpus, const std::string& term) {
        double N = corpus.size();
        double df = 0;
        
        for (const auto& document : corpus) {
            std::unordered_set<std::string> uniqueTerms(document.begin(), document.end());
            if (uniqueTerms.find(term) != uniqueTerms.end()) {
                df++;
            }
        }
        
        return std::log(N / (1 + df));
    }
    
    /**
     * @brief Calcula o IDF probabilístico de um termo em um corpus.
     * @param corpus Vetor de vetores de strings, onde cada vetor interno representa um documento tokenizado.
     * @param term O termo cuja IDF será calculada.
     * @return O valor do IDF probabilístico, dado por log((N - df) / df), onde N é o número de documentos e df é a frequência documental (double).
     */
    static double probabilistic(const std::vector<std::vector<std::string>>& corpus, const std::string& term) {
        double N = corpus.size();
        double df = 0;
        
        for (const auto& document : corpus) {
            std::unordered_set<std::string> uniqueTerms(document.begin(), document.end());
            if (uniqueTerms.find(term) != uniqueTerms.end()) {
                df++;
            }
        }
        
        // O IDF probabilístico pode ter problemas se df = N
        if (df == N) return 0.0;
        
        return std::log((N - df) / df);
    }
    
    /**
     * @brief Calcula e exibe todas as variantes do IDF para um conjunto de termos.
     * @param corpus Vetor de vetores de strings, onde cada vetor interno representa um documento tokenizado.
     * @param terms Vetor de strings contendo os termos a serem analisados.
     */
    static void calculateAllVariants(const std::vector<std::vector<std::string>>& corpus, 
                                    const std::vector<std::string>& terms) {
        std::cout << "Termo\t\tIDF Básico\tIDF Suavizado\tIDF Probabilístico\n";
        std::cout << "-----------------------------------------------------------\n";
        
        for (const auto& term : terms) {
            double basic_idf = basic(corpus, term);
            double smooth_idf = smooth(corpus, term);
            double prob_idf = probabilistic(corpus, term);
            
            std::cout << term << "\t\t" 
                     << basic_idf << "\t\t" 
                     << smooth_idf << "\t\t";
            
            // Verificar se o IDF probabilístico está definido
            if (std::isnan(prob_idf) || std::isinf(prob_idf)) {
                std::cout << "Indefinido";
            } else {
                std::cout << prob_idf;
            }
            
            std::cout << "\n";
        }
    }
};

/**
 * @brief Função principal que demonstra o uso da classe InverseDocumentFrequency.
 *
 * Este programa calcula e exibe as métricas de IDF básico, suavizado e probabilístico para um conjunto
 * de termos em um corpus de documentos tokenizados, utilizando os métodos da classe InverseDocumentFrequency.
 *
 * @return 0 em caso de execução bem-sucedida.
 */
int main() {
    // Corpus de documentos tokenizados para demonstração
    std::vector<std::vector<std::string>> corpus = {
        {"o", "gato", "preto", "caça", "o", "rato", "preto"},
        {"o", "rato", "branco", "corre", "do", "gato"},
        {"o", "cachorro", "late", "para", "o", "gato", "preto"}
    };
    
    std::vector<std::string> terms = {"gato", "preto", "cachorro", "rato"}; ///< Termos a serem analisados.
    
    InverseDocumentFrequency::calculateAllVariants(corpus, terms);
    
    return 0;
}

Este exemplo implementa três variantes do cálculo de IDF discutidas no texto: IDF básico, IDF com suavização e IDF probabilístico.

A classe InverseDocumentFrequency encapsula estes métodos de cálculo. A implementação usa estruturas de dados eficientes como unordered_set para verificar rapidamente a presença de termos em documentos, evitando contagens duplicadas. O método calculateAllVariants gera uma tabela formatada que mostra os valores de IDF para cada termo usando as diferentes formulações, facilitando a comparação.

Note que o código inclui tratamento para o caso em que o IDF probabilístico pode se tornar indefinido, quando um termo aparece em todos os documentos, mostrando como lidar com casos especiais que podem surgir nas aplicações reais.

Cálculo do TF-IDF

Finalmente chegamos a informação que nos interessa. A pontuação final TF-IDF será o resultado do produto das duas métricas:

Na qual, temos:

• $w$ é um termo (palavra) do nosso vocabulário $V$;
• $D_i$ é o $i$-ésimo documento em nossa coleção;
• $Docs$ é nossa coleção completa de documentos, corpus;
• $\text{TF}(w, D_i)$ representa a frequência do termo $w$ no documento $D_i$;
• $\text{IDF}(w, Docs)$ é a frequência inversa do documento w no corpus.

Esta fórmula tem propriedades matemáticas interessantes:

1. Se uma palavra ocorre muito em um documento ($\text{TF}$ alto) mas é comum no corpus ($\text{IDF}$ baixo), sua pontuação TF-IDF será moderada;
2. Se uma palavra ocorre muito em um documento ($\text{TF}$ alto) e é rara no corpus ($\text{IDF}$ alto), sua pontuação TF-IDF será alta;
3. Se uma palavra ocorre pouco em um documento ($\text{TF}$ baixo), sua pontuação TF-IDF será baixa independentemente do $\text{IDF}$.

Contudo, precisamos voltar a matemática. Antes que a perspicaz leitora possa ver um exemplo detalhado do uso do TF-IDF precisamos ver Similaridade de Cosseno.

Similaridade de Cosseno

A Similaridade de Cosseno é uma medida que permite quantificar o quão similares dois vetores são, baseando-se no ângulo entre eles. Em um espaço vetorial de documentos, onde cada dimensão representa um termo, a Similaridade de Cosseno fornece uma medida da similaridade semântica entre os documentos, independente do tamanho dos documentos.

Para dois vetores $\vec{a}$ e $\vec{b}$, a Similaridade de Cosseno será definida como:

Nesta fórmula temos:

• $\vec{a}$ e $\vec{b}$ são vetores $n$-dimensionais;
• $a_i$ e $b_i$ são os $i$-ésimos componentes dos vetores $\vec{a}$ e $\vec{b}$ respectivamente;
• $n$ é a dimensão dos vetores (tamanho do vocabulário);
• $\theta$ é o ângulo entre os dois vetores;

• $

  \vec{a}

  $ e $

  \vec{b}

  $ representam as normas euclidianas dos vetores.

O resultado da aplicação desta fórmula irá variar entre $-1$ e $1$, de tal forma que:

• $1$ indica vetores apontando na mesma direção, documentos muito similares;
• $0$ indica vetores perpendiculares, documentos sem relação;
• $-1$ indica vetores em direções opostas, documentos completamente diferentes.

No contexto de análise de documentos em processamento de linguagem natural, como trabalhamos com frequências não-negativas, o resultado estará sempre entre $0$ e $1$.

Exemplo 1: comparação Simples. Considere um corpus formado por três documentos curtos:

• $D_1$: “O gato caça rato”;
• $D_2$:”O gato dorme muito”;
• $D_3$: “O rato come queijo”.

Após aplicar TF-IDF e considerando apenas os termos $[\text{“gato”, “rato”, “caça”, “dorme”, “come”, “queijo”}]\;$, obtemos os vetores:

• $\vec{D_1} = [0.4, 0.4, 0.5, 0, 0, 0]$;
• $\vec{D_2} = [0.4, 0, 0, 0.5, 0, 0]$;
• $\vec{D_3} = [0, 0.4, 0, 0, 0.5, 0.4]$.

Calculando a similaridade entre $\vec{D_1}$ e $\vec{D_2}$:

Enquanto entre $\vec{D_1}$ e $\vec{D_3}$:

Exemplo 2: aplicação em Busca de Documentos

Imagine agora uma consulta $q$ = “gato caçador”. Após processamento TF-IDF:

$\vec{Q} = [0.6, 0, 0.4, 0, 0, 0]$

Calculando a similaridade com cada documento:

Neste caso, o sistema ranquearia os documentos na ordem: $D_1 > D_2 > D_3$, o que faz sentido intuitivamente, já que $D_1$ contém tanto “gato” quanto um termo relacionado à caça.

A Similaridade de Cosseno é particularmente útil em recuperação de informação porque é independente do tamanho dos documentos, considera a direção dos vetores, não sua magnitude, permite comparações rápidas em grandes conjuntos de documentos e funciona bem com vetores esparsos, característicos de representações TF-IDF.

Exemplo 3: similaridade de cosseno em C++.

#include <iostream>     ///< Para entrada e saída padrão (std::cout).
#include <vector>      ///< Para contêiner std::vector usado no armazenamento de vetores de documentos.
#include <string>      ///< Para std::string, usado em mensagens e formatação.
#include <Eigen/Dense>  ///< Para a biblioteca Eigen, usada em operações de álgebra linear com vetores e matrizes.
#include <iomanip>     ///< Para std::setw, std::fixed e std::setprecision, usados na formatação de saída.

/**
 * @brief Calcula a similaridade de cosseno entre dois vetores.
 * @param v1 Primeiro vetor (Eigen::VectorXd).
 * @param v2 Segundo vetor (Eigen::VectorXd).
 * @return Valor da similaridade de cosseno (double) entre os vetores, no intervalo [-1, 1]. Retorna 0.0 se algum vetor tiver norma zero.
 */
double cosineSimilarity(const Eigen::VectorXd& v1, const Eigen::VectorXd& v2) {
    double dotProduct = v1.dot(v2);
    double norm1 = v1.norm();
    double norm2 = v2.norm();
    
    if (norm1 == 0 || norm2 == 0) return 0.0;
    return dotProduct / (norm1 * norm2);
}

/**
 * @brief Exibe a matriz de similaridade de cosseno entre um conjunto de documentos.
 * @param documents Vetor de vetores Eigen::VectorXd, onde cada vetor representa um documento (por exemplo, vetores TF-IDF).
 */
void printSimilarityMatrix(const std::vector<Eigen::VectorXd>& documents) {
    int n = documents.size();
    Eigen::MatrixXd similarityMatrix = Eigen::MatrixXd::Zero(n, n);
    
    // Calcular similaridade entre todos os pares de documentos
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            similarityMatrix(i, j) = cosineSimilarity(documents[i], documents[j]);
        }
    }
    
    // Imprimir matriz de similaridade
    std::cout << "Matriz de Similaridade de Cosseno:\n";
    std::cout << std::setw(10) << " ";
    for (int i = 0; i < n; ++i) {
        std::cout << std::setw(10) << "Doc " + std::to_string(i+1);
    }
    std::cout << "\n";
    
    for (int i = 0; i < n; ++i) {
        std::cout << std::setw(10) << "Doc " + std::to_string(i+1);
        for (int j = 0; j < n; ++j) {
            std::cout << std::setw(10) << std::fixed << std::setprecision(4) 
                     << similarityMatrix(i, j);
        }
        std::cout << "\n";
    }
}

/**
 * @brief Função principal que demonstra o cálculo de similaridade de cosseno entre documentos e uma consulta.
 *
 * Este programa utiliza vetores TF-IDF para três documentos e uma consulta, calcula a matriz de similaridade
 * entre os documentos, a similaridade entre a consulta e cada documento, e realiza verificações manuais
 * das similaridades usando a fórmula da similaridade de cosseno.
 *
 * @return 0 em caso de execução bem-sucedida.
 */
int main() {
    // Exemplo com vetores TF-IDF para os documentos e uma consulta
    std::vector<Eigen::VectorXd> documents; ///< Vetores TF-IDF dos documentos.

    // Documento 1: "O gato caça rato"
    Eigen::VectorXd D1(6); ///< Vetor TF-IDF para o Documento 1.
    D1 << 0.4, 0.4, 0.5, 0.0, 0.0, 0.0;
    
    // Documento 2: "O gato dorme muito"
    Eigen::VectorXd D2(6); ///< Vetor TF-IDF para o Documento 2.
    D2 << 0.4, 0.0, 0.0, 0.5, 0.0, 0.0;
    
    // Documento 3: "O rato come queijo"
    Eigen::VectorXd D3(6); ///< Vetor TF-IDF para o Documento 3.
    D3 << 0.0, 0.4, 0.0, 0.0, 0.5, 0.4;
    
    // Consulta: "gato caçador"
    Eigen::VectorXd Q(6); ///< Vetor TF-IDF para a consulta.
    Q << 0.6, 0.0, 0.4, 0.0, 0.0, 0.0;
    
    documents = {D1, D2, D3};
    
    // Calcular e imprimir a matriz de similaridade entre documentos
    printSimilarityMatrix(documents);
    
    // Calcular similaridade entre a consulta e cada documento
    std::cout << "\nSimilaridade entre a consulta 'gato caçador' e os documentos:\n";
    for (int i = 0; i < documents.size(); ++i) {
        double sim = cosineSimilarity(Q, documents[i]);
        std::cout << "Documento " << (i+1) << ": " << std::fixed << std::setprecision(4) << sim << "\n";
    }
    
    // Verificação manual das similaridades
    std::cout << "\nVerificação manual das similaridades usando a fórmula:\n";
    
    double sim_D1_D2 = D1.dot(D2) / (D1.norm() * D2.norm());
    std::cout << "sim(D1, D2) = " << std::fixed << std::setprecision(4) << sim_D1_D2 << "\n";
    
    double sim_D1_D3 = D1.dot(D3) / (D1.norm() * D3.norm());
    std::cout << "sim(D1, D3) = " << std::fixed << std::setprecision(4) << sim_D1_D3 << "\n";
    
    double sim_Q_D1 = Q.dot(D1) / (Q.norm() * D1.norm());
    std::cout << "sim(Q, D1) = " << std::fixed << std::setprecision(4) << sim_Q_D1 << "\n";
    
    return 0;
}

Utilizamos os vetores TF-IDF apresentados no Exemplo 1 da seção Similaridade de Cosseno do texto. O código implementa:

1. Função de similaridade de cosseno: calcula o produto escalar dos vetores normalizado pelos seus comprimentos (normas), usando as operações otimizadas da biblioteca Eigen.

2. Matriz de similaridade: calcula e exibe uma matriz que mostra a similaridade entre todos os pares de documentos, facilitando a visualização de quais documentos são mais semelhantes entre si.

3. Similaridade com consulta: demonstra como calcular a similaridade entre uma consulta “gato caçador” e cada documento do corpus.

4. Verificação manual: implementa o cálculo detalhado da fórmula para confirmação dos resultados.

A implementação utiliza os recursos da biblioteca Eigen para operações vetoriais eficientes, como produto escalar (dot) e cálculo de normas (norm). Isso facilita a implementação das fórmulas matemáticas apresentadas no texto.

Exemplo Detalhado de TF-IDF

Vamos analisar um exemplo completo usando um corpus com apenas dois documentos:

• $D_1$: “O gato preto subiu no telhado. O gato dorme no telhado”;
• $D_2$: “O telhado é preto”.

Primeiro, definimos o vocabulário global ordenado:

Agora, vamos calcular o TF-IDF para algumas palavras chave:

Para “gato” em $D_1$:

1. Cálculo do TF:

   • $f(\text{“gato”}, D_1) = 2$ (frequência bruta);
   • Total de palavras em $D_1 = 10$;
   • $\text{TF}(\text{“gato”}, D_1) = \frac{2}{10} = 0.2$.

2. Cálculo do IDF:

   • $ \vert Docs \vert = 2$;
   • $ \vert {D_j \in Docs: \text{“gato”} \in D_j} \vert = 1$;
   • $\text{IDF}(\text{“gato”}, Docs) = \log(\frac{2}{1}) \approx 0.301$.

3. TF-IDF final:

   • $\text{TF-IDF}(\text{“gato”}, D_1) = 0.2 \times 0.301 \approx 0.0602$.

Para “telhado” em $D_2$:

1. Cálculo do TF:

   • $f(\text{“telhado”}, D_2) = 1$;
   • Total de palavras em $D_2 = 4$;
   • $\text{TF}(\text{“telhado”}, D_2) = \frac{1}{4} = 0.25$.

2. Cálculo do IDF:

   • $ \vert Docs \vert = 2$;
   • $ \vert {D_j \in Docs: \text{“telhado”} \in D_j} \vert = 2$;
   • $\text{IDF}(\text{“telhado”}, Docs) = \log(\frac{2}{2}) = 0$.

3. TF-IDF final:

   • $\text{TF-IDF}(\text{“telhado”}, D_2) = 0.25 \times 0 = 0$.

A sagaz leitora deve notar que “telhado” recebeu pontuação zero em $D_2$ porque aparece em todos os documentos do corpus, ilustrando como o TF-IDF penaliza palavras muito comuns.

Para um documento $D_i$, podemos construir um vetor TF-IDF $\vec{tfidf_{D_i}} \in \mathbb{R}^{ \vert V_{global} \vert }$:

Esta representação vetorial é útil em tarefas relacionadas com a recuperação de informação, classificação de documentos, agrupamento de textos similares e sistemas de recomendação baseados em conteúdo. Ou, em outras palavras, todas as atividades comuns, e básicas, do processamento de linguagem natural.

O TF-IDF resolve parcialmente o problema de palavras muito frequentes do BoW, mas ainda mantém algumas limitações, como a perda da ordem das palavras e das relações semânticas.

Para este pobre autor, a perda de conteúdo semântico é a mais preocupante e o principal motivo de continuarmos este texto. Mas, antes, vamos ver um exemplo completo.

Exemplo 1: **TF-IDF para Recuperação de Informação

Para ilustrar o uso do TF-IDF em recuperação de informação, vamos construir um exemplo passo a passo. Imagine que estamos construindo um sistema de busca simplificado para uma pequena coleção de documentos.

• Documento 1: “O gato caçador pula no telhado”;
• Documento 2: “Cachorro late para o gato no quintal”;
• Documento 3: “Pássaro voa alto no céu azul”.

Começamos criando um vocabulário simplificado, considerando todas as palavras em minúsculas e removendo pontuações. Nosso vocabulário será dado por:

1. Cálculo da Frequência do Termo (TF):

Para cada documento e cada termo do vocabulário, calculamos a Frequência do Termo (TF). Vamos usar a frequência bruta do termo no documento.

2. Cálculo da Frequência Inversa nos Documentos (IDF):

Agora, calculamos o IDF para cada termo do vocabulário usando a fórmula básica:

Observação: Utilizamos o logaritmo natural (base $e$). Em aplicações reais, a base do logaritmo não altera o ranqueamento, apenas a escala dos valores.

3. Cálculo do TF-IDF:

Multiplicamos o TF de cada termo em cada documento pelo seu IDF correspondente para obter a matriz TF-IDF:

4. Consulta do Usuário: suponha que o usuário faça a seguinte consulta: “gato no telhado”.

Primeiro, precisamos criar um vetor da consulta usando o mesmo algoritmo que usamos antes. Ou seja, calculamos o vetor TF-IDF para a consulta, usando o mesmo IDF calculado para os documentos. Vamos assumir $TF=1$ para cada termo presente na consulta e $0$ para os demais termos do vocabulário.

5. Cálculo da Similaridade do Cosseno: calculamos a similaridade do cosseno entre o vetor da consulta e o vetor TF-IDF de cada documento.

1. Documento 1 vs. Consulta:

   Vetor Doc 1: $[0.18, 0.48, 0.48, 0.48, 0, 0, 0, 0, 0, 0, 0, 0]$

   Vetor Consulta: $[0.18, 0, 0, 0.48, 0, 0, 0, 0, 0, 0, 0, 0]$

   Similaridade (Doc 1, Consulta) $\approx \frac{(0.18 \times 0.18) + (0.48 \times 0.48)}{\sqrt{(0.18^2 + 0.48^2 + 0.48^2 + 0.48^2)} \times \sqrt{(0.18^2 + 0.48^2)}} \approx 0.92$

2. Documento 2 vs. Consulta:

   Vetor Doc 2: $[0.18, 0, 0, 0, 0.48, 0.48, 0.48, 0, 0, 0, 0, 0]$

   Vetor Consulta: $[0.18, 0, 0, 0.48, 0, 0, 0, 0, 0, 0, 0, 0]$

   Similaridade (Doc 2, Consulta) $\approx \frac{(0.18 \times 0.18)}{\sqrt{(0.18^2 + 0.48^2 + 0.48^2 + 0.48^2)} \times \sqrt{(0.18^2 + 0.48^2)}} \approx 0.16$

3. Documento 3 vs. Consulta:

   Vetor Doc 3: $[0, 0, 0, 0, 0, 0, 0, 0.48, 0.48, 0.48, 0.48, 0.48]$

   Vetor Consulta: $[0.18, 0, 0, 0.48, 0, 0, 0, 0, 0, 0, 0, 0]$

   Similaridade (Doc 3, Consulta) $\approx 0$ (produto escalar é zero)

6. Ranqueamento: com base na similaridade do cosseno, os documentos devem ranqueados em ordem decrescente de similaridade. O que resulta em:

1. Documento 1: Similaridade $\approx 0.92$;
2. Documento 2: Similaridade $\approx 0.16$;
3. Documento 3: Similaridade $\approx 0$.

Finalmente, o Documento 1 deve ser considerado o mais relevante para a consulta “gato no telhado”, o que faz sentido intuitivamente, pois ele contém ambos os termos da consulta e tem uma concentração maior desses termos em relação aos outros documentos. O TF-IDF, neste exemplo simplificado, consegue capturar a relevância do Documento 1 para a consulta, demonstrando seu princípio de funcionamento na recuperação de informação.

Exemplo 2: trabalhando com C++.

Este exemplo apresenta uma implementação completa do algoritmo TF-IDF utilizando a biblioteca Eigen para operações matriciais. A classe TFIDF encapsula todo o processamento, desde a construção do vocabulário até o cálculo da matriz TF-IDF e a busca de documentos similares.

Principais componentes e técnicas utilizadas:

1. Representação vetorial: utilizamos a biblioteca Eigen para criar e manipular matrizes e vetores, o que facilita os cálculos de similaridade e produtos escalares;

2. Construção do vocabulário: o método buildVocabulary() extrai todos os termos únicos do corpus e cria um mapeamento entre termos e índices para acesso eficiente;

3. Cálculo de TF-IDF: implementamos o cálculo de TF normalizada e IDF suavizada, seguindo as fórmulas apresentadas no texto.

4. Matriz TF-IDF: o método computeTFIDFMatrix() calcula a matriz TF-IDF completa, onde cada linha representa um documento e cada coluna um termo do vocabulário. Similaridade de cosseno: Implementamos o cálculo da similaridade de cosseno para comparar documentos entre si ou com uma consulta. Processamento de consultas: O método processQuery() converte uma consulta de texto em um vetor TF-IDF e calcula sua similaridade com todos os documentos do corpus.

Na função main(), demonstramos o uso da classe com o exemplo do corpus de três documentos mencionado no texto. Imprimimos a matriz TF-IDF resultante e testamos uma consulta “gato preto”, mostrando os documentos ordenados por relevância.

#include <iostream>         ///< Para entrada e saída padrão (std::cout).
#include <vector>          ///< Para contêiner std::vector usado no armazenamento de corpus, vocabulário e documentos.
#include <string>          ///< Para std::string, usado em termos e mensagens.
#include <unordered_map>   ///< Para std::unordered_map, usado no mapeamento de termos para índices.
#include <unordered_set>   ///< Para std::unordered_set, usado na construção do vocabulário único.
#include <cmath>           ///< Para std::log, usado no cálculo do IDF.
#include <Eigen/Dense>     ///< Para a biblioteca Eigen, usada em operações de álgebra linear com vetores e matrizes.
#include <iomanip>         ///< Para std::setw, std::fixed e std::setprecision, usados na formatação de saída.

/**
 * @class TFIDF
 * @brief Uma classe para calcular vetores TF-IDF de documentos e processar consultas com base na similaridade de cosseno.
 *
 * Esta classe constrói um vocabulário global a partir de um corpus, calcula a matriz TF-IDF para os documentos,
 * e permite processar consultas para encontrar documentos relevantes usando a métrica de similaridade de cosseno.
 * Utiliza a biblioteca Eigen para operações matriciais e vetoriais.
 */
class TFIDF {
private:
    std::vector<std::vector<std::string>> corpus;      ///< Corpus de documentos tokenizados.
    std::vector<std::string> vocabulary;               ///< Vocabulário global ordenado alfabeticamente.
    Eigen::MatrixXd tfidfMatrix;                       ///< Matriz TF-IDF (documentos x termos).
    std::unordered_map<std::string, int> termToIndex;  ///< Mapeamento de termos para índices no vocabulário.

public:
    /**
     * @brief Construtor que inicializa o modelo TF-IDF com um corpus de documentos.
     * @param documents Vetor de vetores de strings, onde cada vetor interno representa um documento tokenizado.
     */
    TFIDF(const std::vector<std::vector<std::string>>& documents) : corpus(documents) {
        buildVocabulary();
        computeTFIDFMatrix();
    }
    
    /**
     * @brief Constrói o vocabulário global a partir do corpus.
     *
     * Identifica todos os termos únicos no corpus, ordena-os alfabeticamente e cria um mapeamento de termos para índices.
     */
    void buildVocabulary() {
        std::unordered_set<std::string> uniqueTerms;
        
        for (const auto& document : corpus) {
            for (const auto& term : document) {
                uniqueTerms.insert(term);
            }
        }
        
        vocabulary.assign(uniqueTerms.begin(), uniqueTerms.end());
        std::sort(vocabulary.begin(), vocabulary.end()); // Ordenar para consistência
        
        // Criar mapeamento de termos para índices
        for (size_t i = 0; i < vocabulary.size(); ++i) {
            termToIndex[vocabulary[i]] = i;
        }
    }
    
    /**
     * @brief Calcula a frequência de termos (TF) normalizada para um termo em um documento.
     * @param document Vetor de strings representando o documento tokenizado.
     * @param term O termo cuja TF será calculada.
     * @return A frequência normalizada (frequência bruta dividida pelo tamanho do documento) (double).
     */
    double calculateTF(const std::vector<std::string>& document, const std::string& term) {
        double count = 0;
        for (const auto& word : document) {
            if (word == term) {
                count++;
            }
        }
        
        return count / document.size(); // Frequência normalizada
    }
    
    /**
     * @brief Calcula a frequência inversa de documentos (IDF) para um termo.
     * @param term O termo cuja IDF será calculada.
     * @return O valor do IDF suavizado, dado por log(N / (1 + df)), onde N é o número de documentos e df é a frequência documental (double).
     */
    double calculateIDF(const std::string& term) {
        double N = corpus.size();
        double documentFrequency = 0;
        
        for (const auto& document : corpus) {
            for (const auto& word : document) {
                if (word == term) {
                    documentFrequency++;
                    break;
                }
            }
        }
        
        // Aplicar suavização para evitar divisão por zero
        return std::log(N / (1 + documentFrequency));
    }
    
    /**
     * @brief Computa a matriz TF-IDF para todos os documentos e termos do vocabulário.
     *
     * Inicializa a matriz TF-IDF com zeros e calcula os valores TF-IDF para cada par documento-termo.
     */
    void computeTFIDFMatrix() {
        int numDocs = corpus.size();
        int numTerms = vocabulary.size();
        
        // Inicializar matriz TF-IDF com zeros
        tfidfMatrix = Eigen::MatrixXd::Zero(numDocs, numTerms);
        
        // Calcular valores TF-IDF para cada documento e termo
        for (int i = 0; i < numDocs; ++i) {
            const auto& document = corpus[i];
            
            for (int j = 0; j < numTerms; ++j) {
                const auto& term = vocabulary[j];
                double tf = calculateTF(document, term);
                double idf = calculateIDF(term);
                
                tfidfMatrix(i, j) = tf * idf;
            }
        }
    }
    
    /**
     * @brief Calcula a similaridade de cosseno entre dois vetores.
     * @param v1 Primeiro vetor (Eigen::VectorXd).
     * @param v2 Segundo vetor (Eigen::VectorXd).
     * @return Valor da similaridade de cosseno (double) entre os vetores, no intervalo [-1, 1]. Retorna 0.0 se algum vetor tiver norma zero.
     */
    double cosineSimilarity(const Eigen::VectorXd& v1, const Eigen::VectorXd& v2) {
        double dotProduct = v1.dot(v2);
        double norm1 = v1.norm();
        double norm2 = v2.norm();
        
        if (norm1 == 0 || norm2 == 0) return 0.0;
        return dotProduct / (norm1 * norm2);
    }
    
    /**
     * @brief Processa uma consulta e retorna os documentos ordenados por similaridade.
     * @param query Vetor de strings representando a consulta tokenizada.
     * @return Vetor de pares (índice do documento, similaridade), ordenado por similaridade em ordem decrescente.
     */
    std::vector<std::pair<int, double>> processQuery(const std::vector<std::string>& query) {
        // Criar vetor TF-IDF para a consulta
        Eigen::VectorXd queryVector = Eigen::VectorXd::Zero(vocabulary.size());
        
        for (const auto& term : query) {
            if (termToIndex.find(term) != termToIndex.end()) {
                int index = termToIndex[term];
                double tf = static_cast<double>(std::count(query.begin(), query.end(), term)) / query.size();
                double idf = calculateIDF(term);
                queryVector(index) = tf * idf;
            }
        }
        
        // Calcular similaridade com cada documento
        std::vector<std::pair<int, double>> similarities;
        for (int i = 0; i < corpus.size(); ++i) {
            Eigen::VectorXd docVector = tfidfMatrix.row(i);
            double similarity = cosineSimilarity(queryVector, docVector);
            similarities.push_back({i, similarity});
        }
        
        // Ordenar por similaridade (ordem decrescente)
        std::sort(similarities.begin(), similarities.end(), 
                 [](const auto& a, const auto& b) { return a.second > b.second; });
        
        return similarities;
    }
    
    /**
     * @brief Exibe a matriz TF-IDF com formatação.
     */
    void printTFIDFMatrix() {
        std::cout << "Matriz TF-IDF (" << corpus.size() << " documentos x " 
                 << vocabulary.size() << " termos):\n\n";
        
        // Imprimir cabeçalho do vocabulário
        std::cout << std::setw(10) << " ";
        for (const auto& term : vocabulary) {
            std::cout << std::setw(10) << term;
        }
        std::cout << "\n";
        
        // Imprimir valores da matriz
        for (int i = 0; i < corpus.size(); ++i) {
            std::cout << "Doc " << i << ":" << std::setw(4) << " ";
            for (int j = 0; j < vocabulary.size(); ++j) {
                std::cout << std::setw(10) << std::fixed << std::setprecision(4) << tfidfMatrix(i, j);
            }
            std::cout << "\n";
        }
    }
    
    /**
     * @brief Obtém o vocabulário global.
     * @return Referência constante ao vetor de strings do vocabulário.
     */
    const std::vector<std::string>& getVocabulary() const {
        return vocabulary;
    }
};

/**
 * @brief Função principal que demonstra o uso da classe TFIDF.
 *
 * Este programa cria um modelo TF-IDF a partir de um corpus de três documentos, exibe o vocabulário
 * e a matriz TF-IDF, e processa uma consulta para encontrar os documentos mais relevantes com base
 * na similaridade de cosseno.
 *
 * @return 0 em caso de execução bem-sucedida.
 */
int main() {
    // Corpus de documentos tokenizados para demonstração
    std::vector<std::vector<std::string>> corpus = {
        {"o", "gato", "preto", "caça", "o", "rato", "preto"},
        {"o", "rato", "branco", "corre", "do", "gato"},
        {"o", "cachorro", "late", "para", "o", "gato", "preto"}
    };
    
    TFIDF tfidf(corpus); ///< Instância do modelo TF-IDF.
    
    // Imprimir vocabulário
    std::cout << "Vocabulário: ";
    for (const auto& term : tfidf.getVocabulary()) {
        std::cout << term << " ";
    }
    std::cout << "\n\n";
    
    // Imprimir matriz TF-IDF
    tfidf.printTFIDFMatrix();
    
    // Testar uma consulta
    std::vector<std::string> query = {"gato", "preto"}; ///< Consulta tokenizada.
    std::cout << "\nConsulta: ";
    for (const auto& term : query) {
        std::cout << term << " ";
    }
    std::cout << "\n\n";
    
    // Processar consulta e mostrar resultados
    auto results = tfidf.processQuery(query);
    std::cout << "Resultados da busca (ordenados por relevância):\n";
    for (const auto& [docId, similarity] : results) {
        std::cout << "Documento " << docId << ": Similaridade = " 
                 << std::fixed << std::setprecision(4) << similarity << "\n";
        
        // Mostrar o conteúdo do documento
        std::cout << "  Conteúdo: ";
        for (const auto& term : corpus[docId]) {
            std::cout << term << " ";
        }
        std::cout << "\n";
    }
    
    return 0;
}

TF-IDF em C++ Na Prática

O código a seguir implementa um sistema de recuperação de informação utilizando o algoritmo TF-IDF. Ele inclui pré-processamento de texto, construção de vocabulário, cálculo da matriz TF-IDF, e similaridade de cosseno entre documentos e consultas.

A esforçada leitora deve notar que o código é um exemplo simplificado e não inclui todas as funcionalidades de um sistema de recuperação de informação completo. Usando técnicas que ainda não discutimos. No entanto, ele fornece uma base sólida para entender como o TF-IDF pode ser implementado em C++.

#include <iostream>         ///< Para entrada e saída padrão (std::cout).
#include <vector>          ///< Para contêiner std::vector usado no armazenamento de documentos, vocabulário e tokens.
#include <string>          ///< Para std::string, usado em textos, termos e mensagens.
#include <unordered_map>   ///< Para std::unordered_map, usado no mapeamento de termos para índices.
#include <set>             ///< Para std::set, usado na construção do vocabulário único.
#include <algorithm>       ///< Para std::sort e std::find, usados na ordenação e busca.
#include <sstream>         ///< Para std::istringstream, usado na tokenização de texto.
#include <cctype>          ///< Para std::isalpha e std::tolower, usados na normalização de texto.
#include <iomanip>         ///< Para std::setw, std::fixed e std::setprecision, usados na formatação de saída.
#include <Eigen/Dense>     ///< Para a biblioteca Eigen, usada em operações de álgebra linear com vetores e matrizes.

/**
 * @class TextPreprocessor
 * @brief Uma classe para pré-processamento de texto, incluindo normalização, tokenização e remoção de stopwords.
 *
 * Esta classe oferece métodos estáticos para preparar textos para análise, convertendo para minúsculas, removendo
 * pontuação, dividindo em tokens e eliminando palavras irrelevantes (stopwords).
 */
class TextPreprocessor {
public:
    /**
     * @brief Converte texto para minúsculas e remove pontuação.
     * @param text O texto de entrada a ser normalizado.
     * @return O texto normalizado, contendo apenas letras minúsculas e espaços.
     */
    static std::string normalize(const std::string& text) {
        std::string result;
        for (char c : text) {
            if (std::isalpha(c)) {
                result += std::tolower(c);
            } else if (c == ' ' || c == '\t' || c == '\n') {
                result += ' ';
            }
        }
        return result;
    }
    
    /**
     * @brief Divide texto em tokens (palavras).
     * @param text O texto de entrada a ser tokenizado.
     * @return Vetor de strings contendo os tokens extraídos.
     */
    static std::vector<std::string> tokenize(const std::string& text) {
        std::vector<std::string> tokens;
        std::istringstream iss(text);
        std::string token;
        
        while (iss >> token) {
            tokens.push_back(token);
        }
        
        return tokens;
    }
    
    /**
     * @brief Obtém a lista de stopwords em português.
     * @return Referência constante a um conjunto de stopwords predefinidas.
     */
    static const std::set<std::string>& getStopwords() {
        static const std::set<std::string> stopwords = {
            "o", "a", "os", "as", "um", "uma", "uns", "umas",
            "de", "do", "da", "dos", "das", "no", "na", "nos", "nas",
            "em", "para", "por", "com", "sem", "sob", "e", "ou", "mas"
        };
        return stopwords;
    }
    
    /**
     * @brief Remove stopwords de um documento tokenizado.
     * @param tokens Vetor de strings contendo os tokens do documento.
     * @return Vetor de strings com os tokens filtrados, sem stopwords.
     */
    static std::vector<std::string> removeStopwords(const std::vector<std::string>& tokens) {
        std::vector<std::string> filtered;
        const auto& stopwords = getStopwords();
        
        for (const auto& token : tokens) {
            if (stopwords.find(token) == stopwords.end()) {
                filtered.push_back(token);
            }
        }
        
        return filtered;
    }
    
    /**
     * @brief Processa um texto completo: normaliza, tokeniza e remove stopwords.
     * @param text O texto de entrada a ser processado.
     * @return Vetor de strings contendo os tokens processados, sem stopwords.
     */
    static std::vector<std::string> process(const std::string& text) {
        std::string normalized = normalize(text);
        std::vector<std::string> tokens = tokenize(normalized);
        return removeStopwords(tokens);
    }
};

/**
 * @class InformationRetrievalSystem
 * @brief Um sistema de recuperação de informação baseado em TF-IDF.
 *
 * Esta classe implementa um sistema de busca que pré-processa documentos, constrói uma matriz TF-IDF,
 * e permite realizar consultas para recuperar documentos relevantes com base na similaridade de cosseno.
 * Utiliza a biblioteca Eigen para operações matriciais e vetoriais.
 */
class InformationRetrievalSystem {
private:
    std::vector<std::string> rawDocuments;               ///< Documentos originais (não processados).
    std::vector<std::vector<std::string>> processedDocs; ///< Documentos processados (tokenizados e sem stopwords).
    std::vector<std::string> vocabulary;                 ///< Vocabulário global ordenado alfabeticamente.
    std::unordered_map<std::string, int> termToIndex;    ///< Mapeamento de termos para índices no vocabulário.
    Eigen::MatrixXd tfidfMatrix;                         ///< Matriz TF-IDF (documentos x termos).

public:
    /**
     * @brief Adiciona um novo documento ao sistema.
     * @param document O documento de entrada (texto bruto).
     */
    void addDocument(const std::string& document) {
        rawDocuments.push_back(document);
        processedDocs.push_back(TextPreprocessor::process(document));
    }
    
    /**
     * @brief Constrói o vocabulário global a partir dos documentos processados.
     *
     * Identifica todos os termos únicos nos documentos, ordena-os alfabeticamente e cria um mapeamento de termos para índices.
     */
    void buildVocabulary() {
        std::set<std::string> uniqueTerms;
        
        for (const auto& doc : processedDocs) {
            for (const auto& term : doc) {
                uniqueTerms.insert(term);
            }
        }
        
        vocabulary.assign(uniqueTerms.begin(), uniqueTerms.end());
        std::sort(vocabulary.begin(), vocabulary.end());
        
        // Criar mapeamento de termos para índices
        for (size_t i = 0; i < vocabulary.size(); ++i) {
            termToIndex[vocabulary[i]] = i;
        }
    }
    
    /**
     * @brief Calcula a frequência de termos (TF) com suavização logarítmica.
     * @param document Vetor de strings representando o documento tokenizado.
     * @param term O termo cuja TF será calculada.
     * @return O valor do TF, dado por 1 + log(frequência bruta) se a frequência for maior que 0, caso contrário 0 (double).
     */
    double calculateTF(const std::vector<std::string>& document, const std::string& term) {
        int count = 0;
        for (const auto& word : document) {
            if (word == term) {
                count++;
            }
        }
        
        return count > 0 ? 1.0 + std::log(count) : 0.0;
    }
    
    /**
     * @brief Calcula a frequência inversa de documentos (IDF) com suavização.
     * @param term O termo cuja IDF será calculada.
     * @return O valor do IDF, dado por log(N / (1 + df)), onde N é o número de documentos e df é a frequência documental (double).
     */
    double calculateIDF(const std::string& term) {
        int N = processedDocs.size();
        int df = 0;
        
        for (const auto& doc : processedDocs) {
            if (std::find(doc.begin(), doc.end(), term) != doc.end()) {
                df++;
            }
        }
        
        return std::log(N / (1.0 + df));
    }
    
    /**
     * @brief Calcula a matriz TF-IDF para todos os documentos e termos do vocabulário.
     *
     * Inicializa a matriz TF-IDF com zeros e calcula os valores TF-IDF para cada par documento-termo.
     */
    void computeTFIDFMatrix() {
        int numDocs = processedDocs.size();
        int numTerms = vocabulary.size();
        
        tfidfMatrix = Eigen::MatrixXd::Zero(numDocs, numTerms);
        
        for (int i = 0; i < numDocs; ++i) {
            const auto& doc = processedDocs[i];
            
            for (int j = 0; j < numTerms; ++j) {
                const auto& term = vocabulary[j];
                double tf = calculateTF(doc, term);
                double idf = calculateIDF(term);
                tfidfMatrix(i, j) = tf * idf;
            }
        }
    }
    
    /**
     * @brief Calcula o vetor TF-IDF para uma consulta.
     * @param query O texto da consulta a ser processado.
     * @return Vetor TF-IDF (Eigen::VectorXd) representando a consulta.
     */
    Eigen::VectorXd calculateQueryVector(const std::string& query) {
        std::vector<std::string> processedQuery = TextPreprocessor::process(query);
        Eigen::VectorXd queryVector = Eigen::VectorXd::Zero(vocabulary.size());
        
        for (const auto& term : processedQuery) {
            if (termToIndex.find(term) != termToIndex.end()) {
                int index = termToIndex[term];
                double tf = calculateTF(processedQuery, term);
                double idf = calculateIDF(term);
                queryVector(index) = tf * idf;
            }
        }
        
        return queryVector;
    }
    
    /**
     * @brief Calcula a similaridade de cosseno entre dois vetores.
     * @param v1 Primeiro vetor (Eigen::VectorXd).
     * @param v2 Segundo vetor (Eigen::VectorXd).
     * @return Valor da similaridade de cosseno (double) entre os vetores, no intervalo [-1, 1]. Retorna 0.0 se algum vetor tiver norma próxima de zero.
     */
    double cosineSimilarity(const Eigen::VectorXd& v1, const Eigen::VectorXd& v2) {
        double dotProduct = v1.dot(v2);
        double norm1 = v1.norm();
        double norm2 = v2.norm();
        
        if (norm1 < 1e-10 || norm2 < 1e-10) return 0.0;
        return dotProduct / (norm1 * norm2);
    }
    
    /**
     * @brief Busca por documentos relevantes para uma consulta.
     * @param query O texto da consulta.
     * @param topK Número máximo de resultados a retornar (padrão é 3).
     * @return Vetor de pares (índice do documento, similaridade), ordenado por similaridade em ordem decrescente.
     */
    std::vector<std::pair<int, double>> search(const std::string& query, int topK = 3) {
        // Verificar se há documentos no sistema
        if (processedDocs.empty()) {
            return {};
        }
        
        // Calcular vetor TF-IDF para a consulta
        Eigen::VectorXd queryVector = calculateQueryVector(query);
        
        // Calcular similaridades com todos os documentos
        std::vector<std::pair<int, double>> results;
        for (int i = 0; i < processedDocs.size(); ++i) {
            Eigen::VectorXd docVector = tfidfMatrix.row(i);
            double similarity = cosineSimilarity(queryVector, docVector);
            results.push_back({i, similarity});
        }
        
        // Ordenar resultados por similaridade (decrescente)
        std::sort(results.begin(), results.end(), 
                 [](const auto& a, const auto& b) { return a.second > b.second; });
        
        // Retornar apenas os top-K resultados mais relevantes
        if (results.size() > topK) {
            results.resize(topK);
        }
        
        return results;
    }
    
    /**
     * @brief Inicializa o sistema com um conjunto de documentos.
     * @param documents Vetor de strings contendo os documentos brutos.
     */
    void initialize(const std::vector<std::string>& documents) {
        // Limpar estado atual
        rawDocuments.clear();
        processedDocs.clear();
        vocabulary.clear();
        termToIndex.clear();
        
        // Adicionar e processar documentos
        for (const auto& doc : documents) {
            addDocument(doc);
        }
        
        // Construir vocabulário e matriz TF-IDF
        buildVocabulary();
        computeTFIDFMatrix();
    }
    
    /**
     * @brief Exibe informações sobre o sistema.
     */
    void printInfo() {
        std::cout << "Sistema de Recuperação de Informação\n";
        std::cout << "------------------------------------\n";
        std::cout << "Número de documentos: " << rawDocuments.size() << "\n";
        std::cout << "Tamanho do vocabulário: " << vocabulary.size() << " termos\n";
        
        std::cout << "\nAmostra do vocabulário (primeiros 20 termos):\n";
        int count = 0;
        for (const auto& term : vocabulary) {
            std::cout << term << " ";
            if (++count >= 20) break;
        }
        std::cout << "\n\n";
    }
    
    /**
     * @brief Exibe os documentos originais armazenados no sistema.
     */
    void printDocuments() {
        std::cout << "Documentos no sistema:\n";
        std::cout << "---------------------\n";
        for (int i = 0; i < rawDocuments.size(); ++i) {
            std::cout << "Documento " << i << ": " << rawDocuments[i] << "\n";
        }
        std::cout << "\n";
    }
    
    /**
     * @brief Exibe os resultados de uma busca de forma amigável.
     * @param query O texto da consulta.
     * @param results Vetor de pares (índice do documento, similaridade) com os resultados da busca.
     */
    void displaySearchResults(const std::string& query, 
                             const std::vector<std::pair<int, double>>& results) {
        std::cout << "Resultados da busca para: \"" << query << "\"\n";
        std::cout << "----------------------------------------\n";
        
        if (results.empty()) {
            std::cout << "Nenhum resultado encontrado.\n\n";
            return;
        }
        
        for (int i = 0; i < results.size(); ++i) {
            int docId = results[i].first;
            double score = results[i].second;
            
            std::cout << (i+1) << ". [Score: " << std::fixed << std::setprecision(4) << score << "] ";
            std::cout << "Documento " << docId << ": " << rawDocuments[docId] << "\n";
        }
        std::cout << "\n";
    }
};

/**
 * @brief Demonstra o sistema de recuperação de informação com um corpus de exemplo.
 *
 * Inicializa o sistema com um corpus de três documentos e realiza buscas com diferentes consultas,
 * exibindo informações sobre o sistema, os documentos e os resultados das buscas.
 */
void demonstrateWithExampleCorpus() {
    std::vector<std::string> corpus = {
        "O gato preto caça o rato preto",
        "O rato branco corre do gato",
        "O cachorro late para o gato preto"
    };
    
    InformationRetrievalSystem irSystem; ///< Instância do sistema de recuperação de informação.
    irSystem.initialize(corpus);
    
    irSystem.printInfo();
    irSystem.printDocuments();
    
    // Demonstrar busca com consultas variadas
    std::vector<std::string> queries = {
        "gato preto",
        "rato",
        "cachorro late",
        "animal"
    };
    
    for (const auto& query : queries) {
        auto results = irSystem.search(query);
        irSystem.displaySearchResults(query, results);
    }
}

/**
 * @brief Função principal que demonstra o sistema de recuperação de informação baseado em TF-IDF.
 *
 * Executa a demonstração do sistema com um corpus de exemplo, mostrando o funcionamento do pré-processamento
 * de texto e da recuperação de documentos relevantes.
 *
 * @return 0 em caso de execução bem-sucedida.
 */
int main() {
    std::cout << "Demonstração do Sistema de Recuperação de Informação baseado em TF-IDF\n\n";
    demonstrateWithExampleCorpus();
    
    return 0;
}

Este exemplo apresenta uma implementação completa e prática de um sistema de recuperação de informação baseado no algoritmo TF-IDF, utilizando C++20 e a biblioteca Eigen. O sistema implementa todas as etapas necessárias para a construção de um mecanismo de busca textual:

1. Pré-processamento de texto: a classe TextPreprocessor implementa técnicas básicas de processamento de linguagem natural, que ainda não foram discutidas no texto. À saber:

   • Normalização: remoção de pontuação, conversão para minúsculas;
   • Tokenização: divisão do texto em palavras;
   • Remoção de stopwords: palavras muito comuns como artigos e preposições.

2. Indexação: o sistema constrói um vocabulário global a partir dos documentos e cria uma matriz TF-IDF utilizando a biblioteca Eigen.

3. Implementação do TF com suavização logarítmica Implementação do IDF com suavização.

4. Representação vetorial eficiente usando matrizes esparsas.

5. Busca: implementa o processamento de consultas e cálculo de similaridade:

   • Conversão da consulta em um vetor TF-IDF;
   • Cálculo da similaridade de cosseno entre a consulta e todos os documentos;
   • Ordenação dos resultados por relevância.

6. Interface de usuário: fornece métodos para visualizar informações do sistema e resultados de busca.

Na função demonstrateWithExampleCorpus(), utilizamos o corpus de três documentos mencionado no texto como exemplo, e demonstramos buscas com diferentes consultas para mostrar como o sistema ranqueia os documentos por relevância.

Esta implementação é uma aplicação prática dos conceitos teóricos apresentados no texto, mostrando como o TF-IDF pode ser usado para construir um sistema de recuperação de informação funcional.

One-Hot Encoding

Chegamos ao One-Hot Encoding. Embora menos comum para representar diretamente textos inteiros em tarefas de processamento de linguagem natural mais sofisticados, o One-Hot Encoding é frequentemente usado como um passo inicial para representar palavras individuais ou caracteres numericamente em processamentos complexos.

Em One-Hot Encoding, cada palavra, ou caractere, do vocabulário $V$, será representada por um vetor binário $\vec{e_w}$. Neste caso, o tamanho do vetor será igual ao tamanho do vocabulário, $ \vert V \vert $. Para cada palavra $w_i \in V$, o vetor $\vec{e_{w_i}}$ terá todos os valores como $0$, exceto na posição $i$ correspondente à palavra $w_i$ no vocabulário, onde o valor será $1$.

Formalmente, teremos: se $V = {w_1, w_2, …, w_{ \vert V’ \vert }}$ é o vocabulário ordenado, então o One-Hot Encoding para a palavra $w_i$ é um vetor $\vec{e}_{w_i} \in \mathbb{R}^{ \vert V’ \vert }$ tal que:

Para o vocabulário $V’_{global} = { \text{“dorme”}, \text{“é”}, \text{“gato”}, \text{“no”}, \text{“o”}, \text{“preto”}, \text{“subiu”}, \text{“telhado”} }$., o One-Hot Encoding seria:

• $\vec{e_{\text{“dorme”}}} = [1, 0, 0, 0, 0, 0, 0, 0]^T$
• $\vec{e_{\text{“é”}}} = [0, 1, 0, 0, 0, 0, 0, 0]^T$
• $\vec{e_{\text{“gato”}}} = [0, 0, 1, 0, 0, 0, 0, 0]^T$
• $\vec{e_{\text{“no”}}} = [0, 0, 0, 1, 0, 0, 0, 0]^T$
• $\vec{e_{\text{“o”}}} = [0, 0, 0, 0, 1, 0, 0, 0]^T$
• $\vec{e_{\text{“preto”}}} = [0, 0, 0, 0, 0, 1, 0, 0]^T$
• $\vec{e_{\text{“subiu”}}} = [0, 0, 0, 0, 0, 0, 1, 0]^T$
• $\vec{e_{\text{“telhado”}}} = [0, 0, 0, 0, 0, 0, 0, 1]^T$

One-hot encoding é extremamente simples e garante que cada palavra seja representada de forma única e independente. É frequentemente usado como entrada para modelos de aprendizado profundo, especialmente em camadas iniciais de redes neurais.

Os produtos escalares são especialmente úteis quando estamos trabalhando com nossas representações one-hot de palavras. O produto escalar de qualquer vetor one-hot com ele mesmo é um.

Produto escalar de vetores correspondentes (Exemplo com vetores one-hot):

Considere o vetor $a = [0, 1, 0]$. O produto escalar consigo mesmo é:

E o produto escalar de qualquer vetor one-hot com qualquer outro vetor one-hot é zero.

Produto escalar de vetores não correspondentes (Exemplo com vetores one-hot):

Considere os vetores $a = [0, 1, 0]$ e $b = [1, 0, 0]$. O produto escalar é:

Os dois exemplos anteriores mostram como os produtos escalares podem ser usados para medir a similaridade. Como outro exemplo, considere um vetor de valores que representa uma combinação de palavras com diferentes pesos. Uma palavra codificada one-hot pode ser comparada com ele usando o produto escalar para mostrar o quão fortemente essa palavra é representada.

Exemplo de One-Hot Encoding em C++ 20

O código a seguir implementa o One-Hot Encoding em C++20. Ele utiliza a biblioteca Eigen para operações matriciais e demonstra como criar representações one-hot para um conjunto de palavras.

#include <iostream>         ///< Para entrada e saída padrão (std::cout, std::cerr).
#include <vector>          ///< Para contêiner std::vector usado no armazenamento de corpus e vocabulário.
#include <string>          ///< Para std::string, usado em termos e mensagens.
#include <unordered_map>   ///< Para std::unordered_map, usado no mapeamento de termos para índices.
#include <set>             ///< Para std::set, usado na construção do vocabulário único.
#include <algorithm>       ///< Para std::sort, usado na ordenação do vocabulário.
#include <Eigen/Dense>     ///< Para a biblioteca Eigen, usada em operações com vetores (Eigen::VectorXd).
#include <iomanip>         ///< Para std::fixed, std::setprecision e std::setw, usados na formatação de saída.

/**
 * @class OneHotEncoder
 * @brief Uma classe para realizar codificação one-hot de palavras em um corpus.
 *
 * Esta classe constrói um vocabulário global a partir de um corpus de documentos tokenizados e transforma
 * termos em vetores one-hot, representando a presença de um termo com 1.0 na posição correspondente e 0.0
 * nas demais. Utiliza a biblioteca Eigen para operações vetoriais.
 */
class OneHotEncoder {
private:
    std::vector<std::string> vocabulary;            ///< Vocabulário global ordenado alfabeticamente.
    std::unordered_map<std::string, int> termToIndex; ///< Mapeamento de termos para índices no vocabulário.
    size_t vocabularySize;                          ///< Tamanho do vocabulário.

public:
    /**
     * @brief Construtor padrão que inicializa um codificador vazio.
     */
    OneHotEncoder() : vocabularySize(0) {}

    /**
     * @brief Constrói o vocabulário a partir de um corpus de documentos tokenizados.
     * @param corpus Vetor de vetores de strings, onde cada vetor interno representa um documento tokenizado.
     */
    void fit(const std::vector<std::vector<std::string>>& corpus) {
        std::set<std::string> uniqueTerms;
        for (const auto& doc : corpus) {
            for (const auto& term : doc) {
                uniqueTerms.insert(term);
            }
        }

        vocabulary.assign(uniqueTerms.begin(), uniqueTerms.end());
        std::sort(vocabulary.begin(), vocabulary.end()); // Garante ordem consistente
        vocabularySize = vocabulary.size();

        termToIndex.clear();
        for (size_t i = 0; i < vocabularySize; ++i) {
            termToIndex[vocabulary[i]] = i;
        }
        std::cout << "Vocabulário construído com " << vocabularySize << " termos únicos.\n";
    }

    /**
     * @brief Transforma um termo em seu vetor one-hot correspondente.
     * @param term O termo a ser codificado.
     * @return Vetor one-hot (Eigen::VectorXd) com 1.0 na posição do termo e 0.0 nas demais. Retorna vetor de zeros para termos fora do vocabulário (OOV).
     */
    Eigen::VectorXd transform(const std::string& term) const {
        // Cria um vetor de zeros do tamanho do vocabulário
        Eigen::VectorXd oneHotVector = Eigen::VectorXd::Zero(vocabularySize);

        // Procura o índice do termo no mapa
        auto it = termToIndex.find(term);
        if (it != termToIndex.end()) {
            // Se encontrado, define a posição correspondente como 1.0
            oneHotVector(it->second) = 1.0;
        }
        return oneHotVector;
    }

    /**
     * @brief Obtém o vocabulário global.
     * @return Referência constante ao vetor de strings do vocabulário.
     */
    const std::vector<std::string>& getVocabulary() const {
        return vocabulary;
    }

    /**
     * @brief Obtém o tamanho do vocabulário.
     * @return O número de termos no vocabulário (size_t).
     */
    size_t getVocabularySize() const {
        return vocabularySize;
    }

    /**
     * @brief Exibe o vocabulário com seus índices correspondentes.
     */
    void printVocabulary() const {
         std::cout << "\nVocabulário (Termo -> Índice):\n";
         std::cout << "-----------------------------\n";
         for(size_t i = 0; i < vocabulary.size(); ++i) {
              std::cout << "\"" << vocabulary[i] << "\" -> " << i << "\n";
         }
         std::cout << std::endl;
    }
};

/**
 * @brief Função auxiliar para imprimir um vetor Eigen de forma legível.
 * @param vec O vetor Eigen (Eigen::VectorXd) a ser impresso.
 * @param name O nome ou descrição do vetor para exibição.
 */
void printEigenVector(const Eigen::VectorXd& vec, const std::string& name) {
    std::cout << name << " (dim=" << vec.size() << "): [";
    // Imprime apenas alguns elementos para vetores longos, se necessário
    int max_print = 20;
    for (int i = 0; i < vec.size(); ++i) {
        if (i > 0) std::cout << ", ";
        if (vec.size() > max_print && i >= max_print / 2 && i < vec.size() - max_print / 2) {
             if (i == max_print / 2) std::cout << "...";
             continue;
        }
        std::cout << vec(i);
    }
    std::cout << "]\n";
}

/**
 * @brief Função principal que demonstra o uso da classe OneHotEncoder.
 *
 * Este programa cria um codificador one-hot a partir de um corpus de documentos tokenizados, exibe o vocabulário,
 * gera vetores one-hot para termos específicos, verifica propriedades do produto escalar entre vetores one-hot,
 * e demonstra a extração de pesos usando o produto escalar.
 *
 * @return 0 em caso de execução bem-sucedida.
 */
int main() {
    // Corpus de exemplo com documentos tokenizados
    std::vector<std::vector<std::string>> corpus = {
        {"o", "gato", "preto", "caça", "o", "rato", "preto"},
        {"o", "rato", "branco", "corre", "do", "gato"},
        {"o", "cachorro", "late", "para", "o", "gato", "preto"}
    };

    // Criar e treinar o codificador
    OneHotEncoder encoder; ///< Instância do codificador one-hot.
    encoder.fit(corpus);
    encoder.printVocabulary();

    // Obter vetores one-hot para alguns termos
    std::cout << "Vetores One-Hot:\n";
    std::cout << "----------------\n";
    Eigen::VectorXd vecGato = encoder.transform("gato");
    Eigen::VectorXd vecPreto = encoder.transform("preto");
    Eigen::VectorXd vecCachorro = encoder.transform("cachorro");
    Eigen::VectorXd vecOOV = encoder.transform("animal"); // Termo fora do vocabulário

    printEigenVector(vecGato, "OneHot('gato')");
    printEigenVector(vecPreto, "OneHot('preto')");
    printEigenVector(vecCachorro, "OneHot('cachorro')");
    printEigenVector(vecOOV, "OneHot('animal') [OOV]"); // Deve ser um vetor de zeros

    // Verificar propriedades do produto escalar
    std::cout << "\nPropriedades do Produto Escalar:\n";
    std::cout << "-------------------------------\n";

    // Produto escalar de um vetor com ele mesmo (deve ser 1)
    double dotSelfGato = vecGato.dot(vecGato);
    std::cout << "Produto escalar (gato · gato): " << std::fixed << std::setprecision(1) << dotSelfGato << " (Esperado: 1.0)\n";

    // Produto escalar de vetores diferentes (deve ser 0)
    double dotGatoPreto = vecGato.dot(vecPreto);
    std::cout << "Produto escalar (gato · preto): " << std::fixed << std::setprecision(1) << dotGatoPreto << " (Esperado: 0.0)\n";

    double dotGatoCachorro = vecGato.dot(vecCachorro);
    std::cout << "Produto escalar (gato · cachorro): " << std::fixed << std::setprecision(1) << dotGatoCachorro << " (Esperado: 0.0)\n";

    // Produto escalar com vetor OOV (deve ser 0)
    double dotGatoOOV = vecGato.dot(vecOOV);
    std::cout << "Produto escalar (gato · OOV): " << std::fixed << std::setprecision(1) << dotGatoOOV << " (Esperado: 0.0)\n";

    // Exemplo: Usar produto escalar para extrair presença
    Eigen::VectorXd presenceVector = vecGato + vecCachorro; ///< Vetor representando presença de "gato" e "cachorro".
    printEigenVector(presenceVector, "Vetor Presença (gato + cachorro)");

    double weightGato = vecGato.dot(presenceVector);
    double weightPreto = vecPreto.dot(presenceVector);
    double weightCachorro = vecCachorro.dot(presenceVector);

    std::cout << "\nPeso extraído via Produto Escalar:\n";
    std::cout << "  Peso de 'gato' no vetor presença: " << weightGato << "\n";
    std::cout << "  Peso de 'preto' no vetor presença: " << weightPreto << "\n";
    std::cout << "  Peso de 'cachorro' no vetor presença: " << weightCachorro << "\n";

    return 0;
}