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 `
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).*