Processamento de Linguagem Natural

NLP Clássico em Produção: Da Tokenização BPE aos Vetores Semânticos Word2Vec e GloVe

Tratado técnico completo sobre os fundamentos do Processamento de Linguagem Natural (NLP): técnicas de normalização textual e tokenização em subpalavras (BPE, WordPiece e SentencePiece), representações esparsas tradicionais (Bag of Words, TF-IDF e N-Grams), a Hipótese Distribucional de Firth, arquiteturas Word2Vec (CBOW versus Skip-Gram com Negative Sampling) e fatoração matricial global com GloVe.

Antes que um computador possa raciocinar sobre uma frase, resumir um relatório de inteligência cibernética ou manter um diálogo coerente, ele se depara com uma barreira ontológica: chips de silício não entendem letras, palavras ou linguagem natural; eles operam exclusivamente com números, tensores e operações de álgebra linear. O desafio primordial do Processamento de Linguagem Natural (NLP) sempre foi encontrar uma ponte matemática rigorosa entre o simbolismo discreto da linguagem humana e o espaço contínuo dos cálculos vetoriais.

Durante décadas, essa transição dependeu de representações simplistas e esparsas (como contagens de frequência e matrizes booleanas gigantescas), que tratavam cada palavra como um identificador isolado sem conexão com seus sinônimos. A virada histórica do NLP ocorreu com a formalização dos Embeddings Densos (Vetores Semânticos) e dos algoritmos modernos de Tokenização em Subpalavras.

Neste artigo, exploramos a jornada que permitiu aos computadores codificar significado geométrico: do pré-processamento clássico e TF-IDF ao Byte Pair Encoding (BPE), Word2Vec e GloVe.

---

1. Do Texto Bruto ao Espaço Vetorial: Normalização e TF-IDF

A abordagem tradicional de NLP converte documentos de texto em matrizes numéricas através de um pipeline determinístico de limpeza e agregação:

Pipeline Clássico de Normalização

1. Case Folding: Conversão para minúsculas para unificar variações gráficas;

2. Filtragem de Stopwords: Remoção de palavras funcionais de alta frequência sem conteúdo semântico discriminativo (artigos, preposições e conjunções como de, para, o, a);

3. Lematização versus Stemming: O Stemming (como o algoritmo de Porter) trunca palavras de forma heurística até seu radical morfológico (estudando $\to$ estud), enquanto a Lematização utiliza análise morfológica e dicionários para reduzi-la à sua forma de dicionário (foi $\to$ ir).

Bag of Words (BoW) e a Ponderação TF-IDF

No modelo Bag of Words, um documento é representado como um histograma de contagem das palavras do vocabulário, descartando a gramática e a ordem sequencial dos termos. Contudo, palavras comuns que aparecem em quase todos os textos tendem a dominar os escores estatísticos.

O TF-IDF (Term Frequency - Inverse Document Frequency) resolve essa limitação penalizando termos ubíquos e premiando termos específicos que discriminam documentos:

$\text{TF-IDF}(t, d, D) = \text{TF}(t, d) \times \text{IDF}(t, D)$

Onde:

  • $\text{TF}(t, d) = \frac{f_{t, d}}{\sum_{t' \in d} f_{t', d}}$ mede a frequência relativa do termo $t$ dentro do documento específico $d$;
  • $\text{IDF}(t, D) = \ln\left( \frac{1 + |D|}{1 + |\{d \in D : t \in d\}|} \right) + 1$ quantifica a raridade do termo no corpus global $D$.

Se uma palavra aparece 15 vezes em um laudo de segurança ("trojan"), mas aparece em apenas 2 documentos de um acervo de 10.000 laudos, seu IDF será altíssimo, tornando o vetor de TF-IDF um discriminador estatístico poderoso para tarefas de busca e classificação clássica.

       LIMITAÇÃO DAS REPRESENTAÇÕES ESPARSAS ONE-HOT / TF-IDF
Vetor "Rei":    [ 1, 0, 0, 0, 0, ... ]  (Dimensão = 50.000, 99.99% Zeros)
Vetor "Rainha": [ 0, 1, 0, 0, 0, ... ]  (Dimensão = 50.000, 99.99% Zeros)
Produto Interno: Rei · Rainha = 0  -> O computador enxerga como palavras 100% desconectadas!

---

2. A Quebra do Vocabulário Aberto: Algoritmos de Subword Tokenization

A tokenização tradicional por palavras inteiras possui duas falhas graves:

1. Explosão de Vocabulário: Línguas com rica morfologia flexional (como o Português, Alemão ou Russo) geram centenas de milhares de variações para uma mesma raiz verbal, explodindo a matriz de pesos de entrada da rede neural;

2. Palavras Fora do Vocabulário (OOV — Out-of-Vocabulary): Qualquer termo técnico novo, gíria ou erro de digitação é descartado como o token especial ``, cegando o modelo para informações cruciais.

A solução moderna reside nos algoritmos de Tokenização em Subpalavras (Subwords):

Byte Pair Encoding (BPE)

Originalmente concebido como um algoritmo de compressão de dados por Philip Gage em 1994, o BPE foi adaptado para NLP por Sennrich et al. em 2015 e tornou-se a base de modelos como GPT, RoBERTa e LLaMA:

1. O vocabulário inicial é definido como todos os caracteres individuais (ou os 256 bytes possíveis na extensão Byte-fallback BPE);

2. O corpus de treinamento é escaneado para encontrar o par de símbolos adjacentes mais frequente;

3. O par mais frequente é fundido em um novo símbolo único adicionado ao vocabulário;

4. O processo se repete iterativamente até atingir o tamanho de vocabulário desejado (por exemplo, 32.000 ou 100.000 tokens).

# Demonstração didática do funcionamento iterativo do algoritmo BPE
import collections

def treinar_bpe_passo(corpus_tokens: list[list[str]]) -> tuple[list[list[str]], tuple[str, str]]:
    # 1. Conta frequências de todos os pares adjacentes
    pares = collections.defaultdict(int)
    for palavra in corpus_tokens:
        for i in range(len(palavra) - 1):
            pares[(palavra[i], palavra[i+1])] += 1
            
    # 2. Encontra o par mais frequente
    melhor_par = max(pares, key=pares.get)
    
    # 3. Funde o melhor par no corpus
    novo_corpus = []
    p1, p2 = melhor_par
    for palavra in corpus_tokens:
        nova_palavra = []
        i = 0
        while i < len(palavra):
            if i < len(palavra) - 1 and palavra[i] == p1 and palavra[i+1] == p2:
                nova_palavra.append(p1 + p2)
                i += 2
            else:
                nova_palavra.append(palavra[i])
                i += 1
        novo_corpus.append(nova_palavra)
        
    return novo_corpus, melhor_par

# Corpus de teste com caracteres separados
tokens = [
    ['c', 'y', 'b', 'e', 'r'],
    ['s', 'e', 'c', 'u', 'r', 'i', 't', 'y'],
    ['c', 'y', 'b', 'e', 'r', 'a', 't', 'a', 'q', 'u', 'e']
]

for iteracao in range(3):
    tokens, fundido = treinar_bpe_passo(tokens)
    print(f"Iteração {iteracao+1}: Par fundido '{fundido[0]} + {fundido[1]}' -> {tokens}")

Modelos contemporâneos como o SentencePiece operam diretamente sobre o fluxo de bytes UTF-8 sem exigir pré-segmentação por espaços, permitindo tokenizar qualquer idioma do planeta sem perda de caracteres.

---

3. Word2Vec: CBOW e Skip-Gram com Negative Sampling

Em 2013, Tomas Mikolov e sua equipe no Google publicaram o Word2Vec, marcando o nascimento das representações distribuídas densas modernas. O princípio fundamental parte da Hipótese Distribucional: palavras com significados semelhantes ocorrem em contextos similares.

Em vez de matrizes esparsas de 50.000 dimensões cheias de zeros, o Word2Vec mapeia cada palavra para um vetor contínuo denso em $\mathbb{R}^d$ (tipicamente $d \in [100, 300]$).

1. Arquitetura CBOW (Continuous Bag of Words)

O modelo recebe uma janela de palavras de contexto $w_{t-2}, w_{t-1}, w_{t+1}, w_{t+2}$ e tenta prever a palavra central $w_t$. A função de objetivo é a maximização da log-verossimilhança condicional:

$\mathcal{L}_{\text{CBOW}} = \sum_{t=1}^T \ln P(w_t | w_{t-c}, \dots, w_{t+c})$

2. Arquitetura Skip-Gram

O modelo inverte o fluxo: recebe uma única palavra central $w_t$ e tenta prever quais palavras aparecem em sua vizinhança contextual dentro de uma janela de raio $c$:

$\mathcal{L}_{\text{Skip-Gram}} = \sum_{t=1}^T \sum_{-c \le j \le c, j \neq 0} \ln P(w_{t+j} | w_t)$

        ARQUITETURAS FUNDAMENTAIS DO WORD2VEC (Mikolov et al.)
           CBOW (Contexto -> Alvo)                 Skip-Gram (Alvo -> Contexto)
        Contexto            Alvo                Alvo              Contexto
       ┌──────────┐                            ┌──────────┐      ┌──────────┐
       │ w(t-1)   │ ───┐                      │          │ ───► │ w(t-1)   │
       └──────────┘    │                       │          │      └──────────┘
       ┌──────────┐    ▼                       │          │      ┌──────────┐
       │ w(t-2)   │ ───┼──► [ w(t) ]           │   w(t)   │ ───► │ w(t+1)   │
       └──────────┘    ▲                       │          │      └──────────┘
       ┌──────────┐    │                       │          │      ┌──────────┐
       │ w(t+1)   │ ───┘                       └──────────┘ ───► │ w(t+2)   │
       └──────────┘                                              └──────────┘

Amostragem Negativa (Negative Sampling)

Calcular o denominador do Softmax sobre todo o vocabulário $V$ ($\sum_{w' \in V} \exp(\mathbf{v}_{w'}^T \mathbf{v}_w)$) exigiria somar centenas de milhares de termos a cada palavra lida, inviabilizando o treino.

O Negative Sampling reformula a tarefa como múltiplos problemas de regressão logística binária: o modelo deve distinguir o par palavra-contexto verdadeiro (amostra positiva) de $k$ palavras aleatórias retiradas do corpus (amostras negativas):

$\log \sigma(\mathbf{v}_{w_O}'^T \mathbf{v}_{w_I}) + \sum_{i=1}^k \mathbb{E}_{w_i \sim P_n(w)} [\log \sigma(-\mathbf{v}_{w_i}'^T \mathbf{v}_{w_I})]$

Essa formulação reduziu a complexidade computacional por passo de $O(|V|)$ para $O(k)$ (onde $k \approx 5$ a $20$), permitindo treinar modelos sobre bilhões de palavras em poucas horas de GPU.

---

4. GloVe: Vetores Globais por Fatoração Matricial

Enquanto o Word2Vec otimiza previsões locais por janelas móveis, pesquisadores da Universidade de Stanford (Pennington, Socher e Manning) introduziram em 2014 o GloVe (Global Vectors for Word Representation).

A tese do GloVe é que a taxa de probabilidade de coocorrência entre duas palavras e uma palavra de sondagem contém uma riqueza semântica muito mais limpa do que as probabilidades brutas isoladas. Considere a matriz de coocorrência global $X$, onde $X_{ij}$ registra quantas vezes a palavra $j$ apareceu no contexto da palavra $i$:

$P_{ik} = P(k | i) = \frac{X_{ik}}{X_i}$

Se avaliarmos a razão $\frac{P(\text{sólido} | \text{gelo})}{P(\text{sólido} | \text{vapor})}$, ela será muito grande, pois gelo é sólido e vapor não. Para uma palavra neutra como "água", a razão aproxima-se de $1.0$.

O GloVe formula uma função de custo de regressão quadrática ponderada que força o produto escalar dos vetores de palavras a aproximar o logaritmo de suas coocorrências globais:

$J = \sum_{i,j=1}^V f(X_{ij}) \left( \mathbf{w}_i^T \tilde{\mathbf{w}}_j + b_i + \tilde{b}_j - \ln X_{ij} \right)^2$

Onde $f(X_{ij}) = \min(1, (X_{ij} / x_{\max})^\alpha)$ é uma função de ponderação suave que impede que palavras extremamente frequentes dominem o treino e que pares que nunca coocorreram gerem termos $\ln(0)$.

---

5. A Geometria das Analogias Vetoriais

A consequência mais celebrada dos embeddings densos é a emergência de propriedades geométricas lineares de significado. No espaço vetorial do Word2Vec e do GloVe, relações gramaticais e conceituais são codificadas como vetores de deslocamento espacial aproximadamente constantes:

$\mathbf{v}_{\text{Rei}} - \mathbf{v}_{\text{Homem}} + \mathbf{v}_{\text{Mulher}} \approx \mathbf{v}_{\text{Rainha}}$

$\mathbf{v}_{\text{Paris}} - \mathbf{v}_{\text{França}} + \mathbf{v}_{\text{Itália}} \approx \mathbf{v}_{\text{Roma}}$

                       ESPAÇO SEMÂNTICO DE ANALOGIAS VETORIAIS
               ▲
               │          [Rei] ────────────────► [Rainha]
               │            │    Vetor Gênero       │
               │            │                       │
               │  Vetor     │                       │
               │  Realeza   │                       │
               │            ▼                       ▼
               │         [Homem] ───────────────► [Mulher]
               │                 Vetor Gênero
               └────────────────────────────────────────────►

Essas propriedades não foram programadas por regras manuais de linguistas: elas emergiram espontaneamente da otimização matemática sobre as frequências relativas com que os seres humanos combinam palavras na literatura e na internet.

---

Conclusão: A Base para os Modelos Modernos

O Processamento de Linguagem Natural clássico não é um museu de tecnologias obsoletas: ele estabeleceu os princípios fundamentais que sustentam os maiores modelos de linguagem do presente. O conceito de tokenização em subpalavras, a geometria dos espaços de embeddings e a medição de similaridade de cosseno continuam sendo os tijolos elementares sobre os quais operam as camadas de atenção dos Transformers modernos.

---

Fonte de Referência Educativa: Conteúdo técnico estruturado a partir da Formação Kaisen AI University (Apostilas Oficiais de Fundamentos de IA, Engenharia de Modelos e Agentes Autônomos).*