Головна▸Статті▸Graph ML

Knowledge Graphs

Побудова та використання knowledge graphs для ML - entity linking, графові ембедінги, reasoning та інтеграція з нейронними мережами.

mysimulator teamОновлено 2026-01≈ 6 хв читання▶ Open the simulation

Knowledge graphs представляють структуровані знання як сутності та відносини. Вони забезпечують пошукові системи, рекомендаційні системи та question answering. На відміну від неструктурованого тексту, knowledge graphs роблять відносини явними та запитуваними - уможливлюючи reasoning, disambiguation сутностей та multi-hop інференс.

Де використовується

Knowledge graphs забезпечують інтелектуальні застосування:

Відомі приклади: Wikidata, DBpedia, YAGO, ентерпрайз бази знань.

Типові дані

Компонент Опис Приклади
Сутності Вузли/речі Люди, компанії, продукти
Відносини Типи ребер works_at, located_in, part_of
Трійки (голова, відношення, хвіст) (Ейнштейн, народився_в, Німеччина)
Літерали Значення атрибутів Дати, числа, текст
Типи Категорії сутностей Персона, Організація, Місце
Схеми Визначення структури Онтології, таксономії

Що ви робите на практиці

  1. Визначте scope - Які сутності та відносини важливі?
  2. Спроектуйте схему - Онтологія, типи, обмеження
  3. Екстрактуйте сутності - NER, entity linking
  4. Екстрактуйте відносини - Pattern matching, ML екстракція
  5. Резолвіть сутності - Дедуплікація, merge записів
  6. Валідуйте якість - Консистентність, повнота
  7. Увімкніть querying - SPARQL, графові запити
  8. Тренуйте ембедінги - Для ML інтеграції
  9. Будуйте застосування - Пошук, QA, рекомендації

Спочатку базова лінія

Почніть з rule-based екстракції та простого matching:

import re
from collections import defaultdict

class SimpleKnowledgeGraph:
    """Базовий knowledge graph з triple store."""

    def __init__(self):
        self.triples = set()
        self.entity_index = defaultdict(set)
        self.relation_index = defaultdict(set)

    def add_triple(self, head, relation, tail):
        """Додавання трійки до графа."""
        triple = (head, relation, tail)
        self.triples.add(triple)

        self.entity_index[head].add(triple)
        self.entity_index[tail].add(triple)
        self.relation_index[relation].add(triple)

    def query(self, head=None, relation=None, tail=None):
        """Запит трійок за патерном."""
        results = self.triples

        if head is not None:
            results = results & self.entity_index[head]
        if tail is not None:
            results = results & self.entity_index[tail]
        if relation is not None:
            results = results & self.relation_index[relation]

        return list(results)

    def get_neighbors(self, entity, relation=None):
        """Отримання всіх сутностей, з'єднаних з даною."""
        neighbors = []

        for h, r, t in self.entity_index[entity]:
            if relation is None or r == relation:
                if h == entity:
                    neighbors.append((r, t, 'outgoing'))
                else:
                    neighbors.append((r, h, 'incoming'))

        return neighbors

    def path_exists(self, start, end, max_hops=3):
        """Перевірка чи існує шлях між сутностями."""
        visited = {start}
        frontier = {start}

        for hop in range(max_hops):
            next_frontier = set()

            for entity in frontier:
                for _, neighbor, _ in self.get_neighbors(entity):
                    if neighbor == end:
                        return True
                    if neighbor not in visited:
                        next_frontier.add(neighbor)
                        visited.add(neighbor)

            frontier = next_frontier
            if not frontier:
                break

        return False

class RuleBasedExtractor:
    """Екстракція відносин за патернами."""

    def __init__(self):
        self.patterns = {
            'born_in': [
                r'(\w+) was born in (\w+)',
                r'(\w+), born in (\w+)',
            ],
            'works_at': [
                r'(\w+) works at (\w+)',
                r'(\w+) is.*employee of (\w+)',
            ],
            'located_in': [
                r'(\w+) is located in (\w+)',
                r'(\w+), (\w+)',  # Формат Місто, Країна
            ]
        }

    def extract(self, text):
        """Екстракція трійок з тексту."""
        triples = []

        for relation, patterns in self.patterns.items():
            for pattern in patterns:
                matches = re.findall(pattern, text, re.IGNORECASE)
                for match in matches:
                    if len(match) == 2:
                        triples.append((match[0], relation, match[1]))

        return triples

Knowledge Graph Embeddings

Навчання векторних представлень для сутностей та відносин:

import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np

class TransE(nn.Module):
    """TransE embedding модель: h + r ≈ t"""

    def __init__(self, num_entities, num_relations, embedding_dim=100):
        super().__init__()
        self.entity_embeddings = nn.Embedding(num_entities, embedding_dim)
        self.relation_embeddings = nn.Embedding(num_relations, embedding_dim)

        # Ініціалізація
        nn.init.xavier_uniform_(self.entity_embeddings.weight)
        nn.init.xavier_uniform_(self.relation_embeddings.weight)

        # Нормалізація ембедінгів відносин
        self.relation_embeddings.weight.data = F.normalize(
            self.relation_embeddings.weight.data, p=2, dim=1
        )

    def forward(self, heads, relations, tails):
        """Оцінка трійок."""
        h = self.entity_embeddings(heads)
        r = self.relation_embeddings(relations)
        t = self.entity_embeddings(tails)

        # Score: негативна L2 відстань
        score = -torch.norm(h + r - t, p=2, dim=1)
        return score

    def predict_tail(self, head, relation, top_k=10):
        """Прогнозування найбільш ймовірних tail сутностей."""
        h = self.entity_embeddings(head)
        r = self.relation_embeddings(relation)

        # Оцінка всіх сутностей як потенційних tails
        all_entities = self.entity_embeddings.weight
        scores = -torch.norm(h + r - all_entities, p=2, dim=1)

        # Отримання top-k
        top_scores, top_indices = torch.topk(scores, top_k)
        return top_indices, top_scores

class ComplEx(nn.Module):
    """ComplEx: Комплекснозначні ембедінги для асиметричних відносин."""

    def __init__(self, num_entities, num_relations, embedding_dim=100):
        super().__init__()
        self.entity_re = nn.Embedding(num_entities, embedding_dim)
        self.entity_im = nn.Embedding(num_entities, embedding_dim)
        self.relation_re = nn.Embedding(num_relations, embedding_dim)
        self.relation_im = nn.Embedding(num_relations, embedding_dim)

    def forward(self, heads, relations, tails):
        """Оцінка трійок з комплексним скалярним добутком."""
        h_re = self.entity_re(heads)
        h_im = self.entity_im(heads)
        r_re = self.relation_re(relations)
        r_im = self.relation_im(relations)
        t_re = self.entity_re(tails)
        t_im = self.entity_im(tails)

        # Комплексний трилінійний добуток
        score = (h_re * r_re * t_re +
                 h_re * r_im * t_im +
                 h_im * r_re * t_im -
                 h_im * r_im * t_re).sum(dim=1)

        return score

def train_kg_embeddings(model, train_triples, num_entities, 
                        epochs=100, batch_size=1024, margin=1.0):
    """Тренування KG ембедінгів з negative sampling."""
    optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

    for epoch in range(epochs):
        model.train()
        total_loss = 0

        # Перемішування трійок
        np.random.shuffle(train_triples)

        for i in range(0, len(train_triples), batch_size):
            batch = train_triples[i:i+batch_size]

            heads = torch.tensor([t[0] for t in batch])
            relations = torch.tensor([t[1] for t in batch])
            tails = torch.tensor([t[2] for t in batch])

            # Генерація негативних семплів (corrupt tails)
            neg_tails = torch.randint(0, num_entities, (len(batch),))

            # Позитивні та негативні scores
            pos_scores = model(heads, relations, tails)
            neg_scores = model(heads, relations, neg_tails)

            # Margin ranking loss
            loss = F.relu(margin - pos_scores + neg_scores).mean()

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

            total_loss += loss.item()

        if epoch % 10 == 0:
            print(f'Epoch {epoch}: Loss {total_loss:.4f}')

    return model

Entity Resolution

Зіставлення сутностей з різних джерел:

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
import numpy as np

class EntityResolver:
    """Резолв та merge дублікатів сутностей."""

    def __init__(self, similarity_threshold=0.8):
        self.threshold = similarity_threshold
        self.vectorizer = TfidfVectorizer(ngram_range=(1, 3))

    def find_matches(self, entities_a, entities_b):
        """Пошук matching сутностей між двома джерелами."""
        # Створення текстових представлень
        texts_a = [self._entity_to_text(e) for e in entities_a]
        texts_b = [self._entity_to_text(e) for e in entities_b]

        # Векторизація
        all_texts = texts_a + texts_b
        vectors = self.vectorizer.fit_transform(all_texts)

        vectors_a = vectors[:len(texts_a)]
        vectors_b = vectors[len(texts_a):]

        # Обчислення подібностей
        similarities = cosine_similarity(vectors_a, vectors_b)

        # Пошук matches вище порогу
        matches = []
        for i, row in enumerate(similarities):
            best_j = np.argmax(row)
            if row[best_j] >= self.threshold:
                matches.append({
                    'entity_a': entities_a[i],
                    'entity_b': entities_b[best_j],
                    'similarity': row[best_j]
                })

        return matches

    def _entity_to_text(self, entity):
        """Конвертація сутності в текст для пошуку."""
        parts = [entity.get('name', '')]

        if 'aliases' in entity:
            parts.extend(entity['aliases'])
        if 'description' in entity:
            parts.append(entity['description'])

        return ' '.join(parts).lower()

Метрики оцінки

Задача Метрики Примітки
Link prediction MRR, Hits@K Ранг правильного tail серед негативів
Entity resolution Precision, Recall, F1 Якість matching
Relation extraction Precision, Recall, F1 Per-relation та загальний
Triple classification Accuracy, AUC Чи трійка true чи false
Completeness Coverage метрики Скільки відомо vs можливо

Типові помилки та чек-лист

Чек-лист для продакшену

Перед деплоєм: - [ ] Схема задокументована та валідована - [ ] Пайплайн entity resolution протестовано - [ ] Метрики якості встановлено - [ ] Патерни запитів оптимізовано - [ ] Embedding модель оцінено

Після деплою: - [ ] Пайплайн безперервного інгесту - [ ] Моніторинг якості - [ ] Процес еволюції схеми - [ ] Інтеграція фідбеку користувачів - [ ] Розклад перенавчання ембедінгів

Інструменти та стек

Категорія Інструменти
Графові БД Neo4j, Amazon Neptune, Stardog
Triple stores Apache Jena, Blazegraph, Virtuoso
Ембедінги PyKEEN, DGL-KE, AmpliGraph
NER/RE spaCy, Stanza, OpenNRE
Онтології Protégé, OWL, SHACL
Querying SPARQL, Cypher, Gremlin

Приклад міні-кейсу

Сценарій: E-commerce knowledge graph продуктів.

Побудова графа: - Сутності: Продукти, бренди, категорії, атрибути - Відносини: made_by, belongs_to, has_attribute, similar_to - Джерела: Дані каталогу, відгуки, web scraping

Підхід: 1. Екстраговано 2M продуктів, 50K брендів 2. Entity resolution merged дублікати (15% зменшення) 3. Натреновано ComplEx ембедінги для рекомендацій 4. Увімкнено "схожі продукти" та "сумісні аксесуари"

Результати: - 23% збільшення cross-sell revenue - Зменшення неконсистентностей каталогу на 60% - Забезпечено нову функцію "shop by attribute" - 50ms латентність запитів для рекомендацій

Пов'язані сторінки

Додаткові матеріали

Спробуйте наживо

Дослідіть пов'язану модель на практиці: відкрийте Knowledge Graph Builder: Triples, Entities & Shortest-Path Inference і змінюйте параметри під час роботи. Усе лишається у вашому браузері.

▶ Відкрити симуляцію Knowledge Graph Builder: Triples, Entities & Shortest-Path Inference

Що ви знайшли?

Додати кроки відтворення (опційно)