Knowledge graphs представляють структуровані знання як сутності та відносини. Вони забезпечують пошукові системи, рекомендаційні системи та question answering. На відміну від неструктурованого тексту, knowledge graphs роблять відносини явними та запитуваними - уможливлюючи reasoning, disambiguation сутностей та multi-hop інференс.
Де використовується
Knowledge graphs забезпечують інтелектуальні застосування:
- Пошукові системи: Google Knowledge Graph, Bing Satori
- Віртуальні асистенти: Alexa, Siri, Google Assistant
- E-commerce: Графи продуктів, збагачення каталогів
- Охорона здоров'я: Взаємодії ліків, медичні онтології
- Ентерпрайз: Customer 360, видимість ланцюга постачань
- Виявлення фроду: Entity resolution, аналіз відносин
Відомі приклади: Wikidata, DBpedia, YAGO, ентерпрайз бази знань.
Типові дані
| Компонент | Опис | Приклади |
|---|---|---|
| Сутності | Вузли/речі | Люди, компанії, продукти |
| Відносини | Типи ребер | works_at, located_in, part_of |
| Трійки | (голова, відношення, хвіст) | (Ейнштейн, народився_в, Німеччина) |
| Літерали | Значення атрибутів | Дати, числа, текст |
| Типи | Категорії сутностей | Персона, Організація, Місце |
| Схеми | Визначення структури | Онтології, таксономії |
Що ви робите на практиці
- Визначте scope - Які сутності та відносини важливі?
- Спроектуйте схему - Онтологія, типи, обмеження
- Екстрактуйте сутності - NER, entity linking
- Екстрактуйте відносини - Pattern matching, ML екстракція
- Резолвіть сутності - Дедуплікація, merge записів
- Валідуйте якість - Консистентність, повнота
- Увімкніть querying - SPARQL, графові запити
- Тренуйте ембедінги - Для ML інтеграції
- Будуйте застосування - Пошук, 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 можливо |
Типові помилки та чек-лист
- [ ] Розріджені знання: Занадто мало трійок для якості ембедінгів
- [ ] Schema drift: Дані не відповідають онтології
- [ ] Неоднозначність сутностей: Однакова назва, різні сутності
- [ ] Розрідженість відносин: Деякі відносини мають мало прикладів
- [ ] Темпоральні проблеми: Знання змінюються з часом
- [ ] Неповнота: Порушення open-world assumption
- [ ] Шум: Неправильні трійки з екстракції
Чек-лист для продакшену
Перед деплоєм: - [ ] Схема задокументована та валідована - [ ] Пайплайн 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 латентність запитів для рекомендацій
Пов'язані сторінки
- Індекс: ML Field Guide
- Класифікація вузлів
- Named Entity Recognition
- RAG системи
Додаткові матеріали
Спробуйте наживо
Дослідіть пов'язану модель на практиці: відкрийте Knowledge Graph Builder: Triples, Entities & Shortest-Path Inference і змінюйте параметри під час роботи. Усе лишається у вашому браузері.
▶ Відкрити симуляцію Knowledge Graph Builder: Triples, Entities & Shortest-Path Inference