Embeddings de Grafos de Conhecimento

Visão geral

Um grafo de conhecimento (KG, knowledge graph) representa fatos como um conjunto de triplas:

[ (h, r, t) ]

onde (h) (cabeça) e (t) (cauda) são entidades (por exemplo, Paris, France) e (r) é uma relação (por exemplo, capital_of). Esta é a representação central discutida em Regras, Ontologias, Grafos de Conhecimento.

Embeddings de Grafo de Conhecimento (KGE, Knowledge Graph Embeddings) aprendem representações vetoriais de entidades e relações de modo que triplas verdadeiras recebam pontuações altas e triplas falsas recebam pontuações baixas. Essas representações dão suporte a tarefas posteriores (downstream) como:

  • Predição de links (link prediction): prever cabeça/cauda/relação ausente (completação de grafo)
  • Resolução de entidades / alinhamento de entidades (entity resolution / entity alignment): decidir se dois nós se referem à mesma entidade do mundo real (frequentemente entre grafos)
  • Classificação de triplas: decidir se uma tripla é verdadeira/falsa
  • Recomendação e recuperação: ranquear entidades relacionadas dada uma consulta (query pattern)
  • Assistência ao raciocínio: aproximar ou guiar raciocínio simbólico (ver Lógica e Programação Lógica Indutiva)

Métodos de KGE são tipicamente paramétricos, otimizados com aprendizado baseado em gradiente (ver Descida do Gradiente e Retropropagação).

Por que embeddings ajudam (intuição)

Embeddings transformam símbolos discretos em vetores contínuos nos quais a geometria codifica estrutura:

  • Entidades similares se agrupam (por exemplo, cidades próximas de cidades).
  • Relações correspondem a transformações (translações, produtos bilineares, rotações).
  • Pontuar uma tripla se reduz a um cálculo numérico rápido, permitindo ranqueamento escalável sobre milhões de candidatos.

No entanto, embeddings não são “lógica” por si só: eles aproximam padrões relacionais estatisticamente e podem violar restrições rígidas, a menos que sejam explicitamente impostas.

Configuração formal

Sejam:

  • (\mathcal{E}) o conjunto de entidades, (|\mathcal{E}| = n)
  • (\mathcal{R}) o conjunto de relações, (|\mathcal{R}| = m)
  • (\mathcal{T} \subseteq \mathcal{E} \times \mathcal{R} \times \mathcal{E}) as triplas observadas

KGE atribui parâmetros:

  • um embedding de entidade (\mathbf{e} \in \mathbb{R}^d) (ou (\mathbb{C}^d))
  • um embedding/parâmetro de relação (\mathbf{r}) (a forma depende do modelo)

e uma função de pontuação:

[ f(h, r, t) \in \mathbb{R} ]

Quanto maior (f), mais “provavelmente verdadeiro”.

O treinamento ajusta os embeddings para que triplas observadas tenham pontuação maior do que triplas corrompidas (negativas).

Famílias centrais de modelos de KGE

Modelos translacionais: TransE

TransE representa relações como translações no espaço de embeddings:

[ \mathbf{h} + \mathbf{r} \approx \mathbf{t} ]

Uma pontuação comum:

[ f(h,r,t) = -|\mathbf{h} + \mathbf{r} - \mathbf{t}|_{p} ]

onde (p \in {1,2}). (Distância negativa, então maior é melhor.)

Pontos fortes

  • Simples, escalável, baseline forte
  • Funciona bem para relações “um-para-um” e muitas-para-uma quando bem ajustado

Limitações

  • Tem dificuldade com relações 1-para-N / N-para-1 / N-para-N porque um único vetor de translação precisa servir para muitas caudas/cabeças diferentes.
  • É difícil modelar relações simétricas de forma limpa sem colapso.

Exemplo prático Se capital_of(Paris, France) é verdadeiro, o TransE tenta fazer:

[ \mathbf{Paris} + \mathbf{capital_of} \approx \mathbf{France} ]

Então, para uma consulta (Paris, capital_of, ?), os vizinhos mais próximos de (\mathbf{Paris} + \mathbf{capital_of}) são países candidatos.

Bilinear / correspondência semântica: DistMult

DistMult usa uma interação bilinear diagonal:

[ f(h,r,t) = \langle \mathbf{h}, \mathbf{r}, \mathbf{t} \rangle = \sum_{i=1}^d h_i , r_i , t_i ]

Pontos fortes

  • Eficiente e frequentemente forte
  • Bom para muitos tipos de relação

Limitação-chave: simetria DistMult é simétrico em (h) e (t):

[ f(h,r,t) = f(t,r,h) ]

Logo, ele não consegue representar relações antissimétricas como born_in(person, city) (onde inverter geralmente se torna falso).

Embeddings com valores complexos: ComplEx

ComplEx estende o DistMult para vetores complexos:

  • Entidades: (\mathbf{h}, \mathbf{t} \in \mathbb{C}^d)
  • Relações: (\mathbf{r} \in \mathbb{C}^d)

Pontuação:

[ f(h,r,t) = \Re\left(\langle \mathbf{h}, \mathbf{r}, \overline{\mathbf{t}} \rangle\right) ]

onde (\overline{\mathbf{t}}) é o conjugado complexo e (\Re(\cdot)) é a parte real.

Por que isso importa O conjugado complexo introduz assimetria, então o ComplEx pode modelar relações antissimétricas mantendo eficiência similar à do DistMult.

Modelos rotacionais: RotatE

RotatE modela relações como rotações no espaço complexo:

  • Entidades (\mathbf{h}, \mathbf{t} \in \mathbb{C}^d)
  • Relações (\mathbf{r}) restritas a módulo unitário: (|r_i| = 1)

A relação atua como:

[ \mathbf{t} \approx \mathbf{h} \circ \mathbf{r} ]

(onde (\circ) é a multiplicação elemento a elemento).

A pontuação frequentemente usa distância:

[ f(h,r,t) = -|\mathbf{h} \circ \mathbf{r} - \mathbf{t}| ]

Pontos fortes O RotatE pode modelar naturalmente padrões relacionais importantes:

  • Simetria: rotação por 0 (ou (\pi) sob algumas convenções)
  • Inversão: a relação inversa corresponde à rotação conjugada complexa
  • Composição: compor relações corresponde a multiplicar rotações

Isso corresponde a uma estrutura “algébrica suave” similar ao que regras simbólicas expressam.

Objetivos de treinamento

O treinamento de KGE geralmente é formulado como ranqueamento ou classificação binária sobre triplas.

Amostragem negativa (corrupção de triplas)

Como a maioria dos KGs contém apenas fatos positivos, geramos negativos corrompendo a cabeça ou a cauda:

  • A partir de ((h, r, t)), criar ((h', r, t)) ou ((h, r, t'))
  • (h') ou (t') é amostrado a partir das entidades

Aprimoramentos comuns:

  • Restrições de tipo: amostrar apenas entidades de um tipo plausível (por exemplo, a cauda de capital_of deveria ser um país)
  • Amostragem Bernoulli (Bernoulli sampling): escolher se corrompe a cabeça ou a cauda com base nas propriedades de mapeamento da relação (1-para-N vs N-para-1)
  • Mineração de negativos difíceis (hard negative mining): amostrar negativos que o modelo atual pontua alto (mais informativos)

Ressalva importante: muitos “negativos” podem ser, na verdade, desconhecidos-mas-verdadeiros devido à incompletude (frequentemente uma suposição de mundo aberto em KGs). Por isso, protocolos de avaliação importam.

Perda de ranqueamento por margem (pareada)

Um objetivo clássico (usado no TransE e em muitos modelos iniciais) é o ranqueamento baseado em margem:

[ \mathcal{L} = \sum_{(h,r,t)\in \mathcal{T}} \sum_{(h',r,t')\in \mathcal{T}^-} \max\big(0,; \gamma - f(h,r,t) + f(h',r,t')\big) ]

  • (\gamma > 0) é uma margem
  • Incentiva triplas positivas a pontuarem pelo menos (\gamma) acima das negativas

Perdas logísticas / softplus (pontuais)

Muitas implementações modernas usam um objetivo mais suave com sigmoide:

[ \mathcal{L} = \sum_{x \in \mathcal{T}\cup \mathcal{T}^-} \log\left(1 + \exp(-y_x , f(x))\right) ]

onde (y_x = +1) para positivas e (-1) para negativas.

Isso se comporta como classificação binária, mas ainda dá suporte a ranqueamento.

Regularização e restrições

Técnicas comuns:

  • Regularização (L_2) nos embeddings
  • Restrições de norma (por exemplo, (|\mathbf{e}| \le 1)) para evitar inflação trivial de pontuação
  • Restrições específicas por relação (por exemplo, módulo unitário no RotatE)

Loop prático de treinamento (esboço mínimo)

Abaixo há um esboço simplificado ao estilo PyTorch para amostragem negativa e uma perda por margem:

# triples: (h_idx, r_idx, t_idx)
# entity_emb: [num_entities, d]
# rel_emb:    [num_relations, d]

def score_transe(h, r, t):
    return -torch.norm(h + r - t, p=1, dim=-1)

for batch in loader(triples, batch_size=1024):
    h, r, t = batch[:,0], batch[:,1], batch[:,2]
    h_e = entity_emb[h]
    r_e = rel_emb[r]
    t_e = entity_emb[t]

    pos = score_transe(h_e, r_e, t_e)

    # negative sampling: corrupt tail
    t_neg = torch.randint(0, num_entities, size=t.shape, device=t.device)
    t_neg_e = entity_emb[t_neg]
    neg = score_transe(h_e, r_e, t_neg_e)

    margin = 1.0
    loss = torch.relu(margin - pos + neg).mean()

    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

Sistemas reais adicionam: múltiplos negativos por positivo, negativos filtrados, corrupção mista de cabeça/cauda, regularização e batching eficiente.

Protocolos de avaliação (o que significa “bom”)

Dada uma tripla de teste ((h,r,t)), avalie:

  • Predição de cauda: ranquear todos os candidatos (t' \in \mathcal{E}) por (f(h,r,t'))
  • Predição de cabeça: ranquear todos os candidatos (h' \in \mathcal{E}) por (f(h',r,t))

Métricas:

  • MRR (Mean Reciprocal Rank): [ \mathrm{MRR} = \frac{1}{N}\sum_{i=1}^N \frac{1}{\mathrm{rank}_i} ]
  • Hits@K: fração de consultas em que a entidade correta está no top K (por exemplo, Hits@1, Hits@10)
  • Às vezes Mean Rank (MR), embora seja sensível a outliers

Ranqueamento “Raw” vs “Filtered”

Como um KG é incompleto, ao ranquear para ((h,r,?)) pode haver múltiplas caudas verdadeiras além de (t). Se você ranquear contra todas as entidades, o modelo pode ser penalizado por colocar outra cauda verdadeira acima de (t).

A correção amplamente usada é a avaliação filtrada (filtered evaluation):

  • Ao ranquear candidatos, remova qualquer candidato (t') tal que ((h,r,t')) seja conhecido como verdadeiro em treino/validação/teste, exceto o alvo (t).

Métricas filtradas são padrão em benchmarks como FB15k-237 e WN18RR.

Armadilhas comuns

  • Vazamento via relações inversas: Alguns datasets (historicamente WN18/FB15k) continham padrões inversos quase triviais que inflacionam as pontuações. Benchmarks modernos reduzem isso.
  • Tratamento de empates: Se muitos candidatos tiverem pontuações idênticas, o cálculo de rank precisa definir como empates são desfeitos.
  • Transdutivo vs indutivo: KGE clássico assume que todas as entidades no teste foram vistas durante o treinamento (transdutivo). Variantes indutivas precisam de mecanismos adicionais (codificadores de texto, GNNs, ou funções composicionais).

Completação de grafo em KGs corporativos

Organizações usam KGE para propor fatos ausentes:

  • works_at(Alice, ?) sugere prováveis empregadores
  • part_of(ComponentX, ?) sugere montagens/assemblies

Fluxo de trabalho típico:

  1. Treinar embeddings com fatos curados
  2. Gerar predições top-k para relações selecionadas
  3. Aplicar restrições (tipos, regras de conformidade, validade temporal)
  4. Revisão humana ou validação posterior (downstream)

Resolução de entidades / alinhamento de entidades

Se você tem duplicatas como IBM vs International_Business_Machines, embeddings podem ajudar por meio de:

  • Comparar vetores de entidades diretamente (similaridade do cosseno)
  • Comparar vizinhanças (entidades com contextos relacionais similares ficam com embeddings similares)

No alinhamento entre grafos (por exemplo, mapear entidades entre dois KGs), uma abordagem comum é:

  • Aprender embeddings em um espaço compartilhado usando alinhamentos semente (entidades pareadas)
  • Casar vizinhos mais próximos sob distância do cosseno ou L2

Nota: KGE puro frequentemente tem dificuldade se grafos tiverem esquemas diferentes ou sobreposição esparsa; métodos híbridos incorporam texto, nomes e atributos.

Recomendação e busca semântica

Consultas como “empresas de energia renovável sediadas na Alemanha” podem ser aproximadas recuperando entidades próximas no espaço de embeddings e então aplicando filtros simbólicos (tipos, restrições). Na prática, embeddings frequentemente complementam consultas simbólicas (por exemplo, SPARQL) em vez de substituí-las.

Expressividade: que padrões os modelos conseguem capturar?

Raciocínio simbólico frequentemente depende de padrões como simetria, inversão e composição. Modelos de KGE diferem no que conseguem representar naturalmente:

  • Relação simétrica (r(x,y) \Rightarrow r(y,x)) (por exemplo, married_to)
    • DistMult lida com simetria facilmente
  • Relação antissimétrica (por exemplo, parent_of)
    • ComplEx e RotatE conseguem representá-la; DistMult não
  • Relações inversas (r^{-1})
    • RotatE modela inversas de forma elegante (rotação inversa)
  • Regras composicionais (r_1(x,y) \land r_2(y,z) \Rightarrow r_3(x,z))
    • RotatE pode aproximar via composição de rotações; outros modelos podem exigir mais capacidade ou interações aprendidas

Ainda assim, essas são propriedades suaves: o modelo pode aproximar padrões sem impô-los universalmente.

Relação com aprendizado de regras, ILP e IA neuro-simbólica

KGE fica em uma interseção entre aprendizado estatístico e estrutura simbólica.

Como embeddings se relacionam com ILP e aprendizado de regras

Programação Lógica Indutiva aprende regras lógicas explícitas (frequentemente cláusulas de Horn) como:

[ \text{parent_of}(x,y) \land \text{parent_of}(y,z) \Rightarrow \text{grandparent_of}(x,z) ]

KGE, em contraste, aprende estrutura relacional implícita em vetores. A conexão aparece de várias formas:

  • Embeddings como semântica suave: Se um KG contém muitas instâncias de uma regra, embeddings podem codificá-la como uma regularidade geométrica (por exemplo, composições de relações se comportando de modo consistente).
  • Extração de regras a partir de embeddings: É possível minerar regras candidatas sondando quais composições de relações se alinham (aproximadamente) com outra relação no espaço de embeddings.
  • Treinamento híbrido: Regras descobertas por ILP/mineradores de regras podem ser injetadas como restrições adicionais de treinamento (“se o corpo da regra é verdadeiro, então a cabeça deve pontuar alto”), melhorando generalização e interpretabilidade.

Abordagens neuro-simbólicas com KGE

Sistemas neuro-simbólicos buscam combinar aprendizado neural com raciocínio simbólico (ver Programação Lógica (Prolog, Datalog) e Lógica):

  • KGE + restrições lógicas: Adicionar penalidades diferenciáveis que imponham restrições (simetria, transitividade, tipagem de domínio/intervalo).
  • KGE + raciocínio diferenciável: Usar embeddings como uma camada de pontuação dentro de um provador de teoremas neural ou de um motor de consultas diferenciável.
  • Ontologias / Lógicas de Descrição: Quando um KG vem com uma ontologia (TBox), restrições de Lógicas de Descrição podem regularizar o aprendizado de embeddings (por exemplo, impondo consistência de subclasse/tipo).

Uma visão prática: embeddings fornecem inferência aproximada rápida e generalização; métodos simbólicos fornecem exatidão, restrições e explicações. Muitos sistemas reais usam embeddings para propor candidatos e regras/restrições para validá-los ou explicá-los.

Dicas práticas para usar KGE em sistemas reais

Preparação de dados importa

  • Canonize entidades e relações: IDs consistentes, trate aliases.
  • Gerencie literais/atributos: KGE clássico foca em triplas entidade–relação–entidade; atributos como strings e números frequentemente exigem extensões ou modelos separados.
  • Fatos temporais e contextuais: se relações são delimitadas no tempo (por exemplo, president_of), considere variantes temporais de KGE ou padrões de reificação.

Escolha um modelo com base nos tipos de relação

  • Comece com baselines fortes: TransE, DistMult, ComplEx, RotatE.
  • Se você espera muitas relações antissimétricas: prefira ComplEx/RotatE em vez de DistMult.
  • Se padrões composicionais são fundamentais: RotatE frequentemente é uma boa escolha.

Monitore com a avaliação certa

  • Use MRR/Hits@K filtrados para predição de links padrão.
  • Avalie por relação se seu KG tem características de relação diversas.
  • Para resolução de entidades, reporte precisão/recall em um limiar e acurácia top-k para geração de candidatos.

Interpretabilidade e governança

Embeddings podem ser difíceis de explicar. Em cenários de alto risco:

  • Use embeddings para geração de candidatos
  • Aplique restrições simbólicas, revisão humana ou validação baseada em regras para decisões finais
  • Rastreie proveniência e calibração de confiança

Resumo

Embeddings de Grafo de Conhecimento aprendem representações vetoriais de entidades e relações que fazem triplas verdadeiras pontuarem alto. Modelos como TransE, DistMult, ComplEx e RotatE diferem em como representam relações (translações, correspondência bilinear, interações complexas, rotações), o que afeta quais padrões relacionais conseguem capturar.

O treinamento tipicamente depende de amostragem negativa e perdas de ranqueamento/classificação (ranqueamento por margem, logística/softplus). A avaliação é comumente realizada via métricas de predição de links filtrada como MRR e Hits@K.

No panorama mais amplo de representação de conhecimento, embeddings complementam métodos simbólicos: eles fornecem inferência aproximada escalável e generalização, enquanto aprendizado de regras/ILP e abordagens baseadas em lógica fornecem estrutura explícita, restrições e explicações — frequentemente combinadas em sistemas neuro-simbólicos.