Графовые базы данных и Python: анализ сложных взаимосвязей

# Установка
pip install neo4j

# Базовое подключение
from neo4j import GraphDatabase

class Neo4jConnection:
def __init__(self, uri, user, password):
self.driver = GraphDatabase.driver(uri, auth=(user, password))

def close(self):
self.driver.close()

def query(self, query, parameters=None):
with self.driver.session() as session:
result = session.run(query, parameters or {})
return [record for record in result]

# Использование
conn = Neo4jConnection("bolt://localhost:7687", "neo4j", "password")
result = conn.query("MATCH (n:Person) RETURN n.name LIMIT 5")
print(result)
conn.close()

# Установка
pip install py2neo

# Создание узлов и связей
from py2neo import Graph, Node, Relationship

graph = Graph("bolt://localhost:7687", auth=("neo4j", "password"))

# Транзакция
tx = graph.begin()

# Создание узлов
alice = Node("Person", name="Alice", age=30)
bob = Node("Person", name="Bob", age=35)
tx.create(alice)
tx.create(bob)

# Создание отношения
friendship = Relationship(alice, "KNOWS", bob, since=2010)
tx.create(friendship)

# Фиксация транзакции
tx.commit()

# Запрос с возвращением результата в виде объектов Python
result = graph.run("""
MATCH (p:Person)-[r:KNOWS]->(friend)
WHERE p.name = $name
RETURN p, r, friend
""", name="Alice").data()

print(result)

# Установка
pip install networkx matplotlib

# Создание и визуализация графа
import networkx as nx
import matplotlib.pyplot as plt

# Создаём направленный граф
G = nx.DiGraph()

# Добавляем узлы с атрибутами
G.add_node(1, name='Алиса')
G.add_node(2, name='Боб')
G.add_node(3, name='Карл')

# Добавляем рёбра с весами
G.add_edge(1, 2, weight=3)
G.add_edge(2, 3, weight=2)
G.add_edge(1, 3, weight=5)

# Визуализация
pos = nx.spring_layout(G) # Позиции для узлов
nx.draw(G, pos, with_labels=True, node_color='lightblue', node_size=500, arrowsize=20)
labels = nx.get_edge_attributes(G, 'weight')
nx.draw_networkx_edge_labels(G, pos, edge_labels=labels)
plt.show()

# Анализ графа с помощью NetworkX
import networkx as nx

# Создаём тестовый граф
G = nx.karate_club_graph() # Знаменитый граф "Клуб карате Закари"

# Основные метрики графа
print(f"Количество узлов: {G.number_of_nodes()}")
print(f"Количество рёбер: {G.number_of_edges()}")
print(f"Плотность графа: {nx.density(G)}")

# Степенная централизация – сколько связей у каждого узла
degree_dict = dict(G.degree())
print(f"Узлы с максимальной степенью: {sorted(degree_dict.items(), key=lambda x: x[1], reverse=True)[:3]}")

# Центральность по посредничеству (betweenness)
betweenness = nx.betweenness_centrality(G)
print(f"Наиболее центральные узлы (по betweenness): {sorted(betweenness.items(), key=lambda x: x[1], reverse=True)[:3]}")

# Выявление сообществ методом Louvain
try:
from community import best_partition
partition = best_partition(G)
print(f"Количество сообществ: {len(set(partition.values()))}")
except ImportError:
print("Установите python-louvain: pip install python-louvain")

# Поиск кратчайшего пути между двумя узлами
path = nx.shortest_path(G, source=0, target=33)
print(f"Кратчайший путь от узла 0 до узла 33: {path}")

# Установка (требует предварительной установки Graphviz)
# На Ubuntu: sudo apt-get install graphviz graphviz-dev
# На macOS: brew install graphviz
# На Windows: через Chocolatey или напрямую с graphviz.org
pip install pygraphviz

# Создание и визуализация графа
import pygraphviz as pgv

# Создаём граф
G = pgv.AGraph(directed=True)

# Добавляем узлы с атрибутами
G.add_node("Москва", color="red", shape="circle")
G.add_node("Санкт-Петербург", color="blue", shape="circle")
G.add_node("Казань", color="green", shape="circle")

# Добавляем рёбра с атрибутами
G.add_edge("Москва", "Санкт-Петербург", label="650 км", color="black")
G.add_edge("Москва", "Казань", label="800 км", color="black")
G.add_edge("Санкт-Петербург", "Казань", label="1400 км", style="dashed")

# Устанавливаем макет и сохраняем визуализацию
G.layout(prog='dot') # Используем алгоритм компоновки 'dot'
G.draw('cities.png') # Сохраняем как PNG

import pygraphviz as pgv
import networkx as nx
import community # python-louvain пакет

# Создаём тестовую сеть с помощью NetworkX
G_nx = nx.karate_club_graph()

# Выявляем сообщества с помощью алгоритма Louvain
partition = community.best_partition(G_nx)
communities = max(partition.values()) + 1

# Преобразуем в PyGraphviz для визуализации
G = pgv.AGraph(strict=False, directed=False)

# Цветовая палитра для сообществ
colors = ['red', 'blue', 'green', 'yellow', 'purple', 'orange', 'brown', 'pink']

# Добавляем узлы с цветами на основе принадлежности к сообществам
for node, data in G_nx.nodes(data=True):
comm = partition[node]
G.add_node(node, color=colors[comm % len(colors)], 
style="filled", fillcolor=colors[comm % len(colors)])

# Добавляем рёбра
for source, target in G_nx.edges():
# Рёбра внутри сообщества – толстые, между сообществами – тонкие
if partition[source] == partition[target]:
G.add_edge(source, target, penwidth=2.0)
else:
G.add_edge(source, target, penwidth=0.5, style="dashed")

# Устанавливаем параметры визуализации
G.graph_attr.update({
'label': 'Анализ сообществ в клубе карате',
'fontsize': '16',
'fontname': 'Arial',
'bgcolor': 'lightgray'
})

# Устанавливаем макет и сохраняем
G.layout(prog='neato') # Используем force-directed layout
G.draw('karate_club_communities.png')

from neo4j import GraphDatabase
import pandas as pd
import numpy as np

# Подключение к Neo4j
driver = GraphDatabase.driver("bolt://localhost:7687", auth=("neo4j", "password"))

# Функция для выполнения запросов
def run_query(query, params={}):
with driver.session() as session:
return session.run(query, params).data()

# Очистка существующих данных (для демо)
run_query("MATCH (n) DETACH DELETE n")

# Создание ограничений для повышения производительности
run_query("CREATE CONSTRAINT IF NOT EXISTS FOR (u:User) REQUIRE u.id IS UNIQUE")
run_query("CREATE CONSTRAINT IF NOT EXISTS FOR (p:Product) REQUIRE p.id IS UNIQUE")
run_query("CREATE CONSTRAINT IF NOT EXISTS FOR (c:Category) REQUIRE c.name IS UNIQUE")

# Генерация синтетических данных
np.random.seed(42)
num_users = 100
num_products = 50
num_categories = 5

# Создание пользователей
users = [{"id": f"user{i}", "age": np.random.randint(18, 65)} for i in range(num_users)]
user_query = """
UNWIND $users AS user
CREATE (u:User {id: user.id, age: user.age})
"""
run_query(user_query, {"users": users})

# Создание категорий
categories = [{"name": f"category{i}"} for i in range(num_categories)]
category_query = """
UNWIND $categories AS category
CREATE (c:Category {name: category.name})
"""
run_query(category_query, {"categories": categories})

# Создание продуктов и связей с категориями
products = []
for i in range(num_products):
cat = f"category{np.random.randint(0, num_categories)}"
products.append({"id": f"product{i}", "price": np.random.randint(10, 1000), "category": cat})

product_query = """
UNWIND $products AS product
CREATE (p:Product {id: product.id, price: product.price})
WITH p, product
MATCH (c:Category {name: product.category})
CREATE (p)-[:BELONGS_TO]->(c)
"""
run_query(product_query, {"products": products})

# Создание связей пользователей и продуктов (покупки)
purchases = []
for user_id in range(num_users):
# Каждый пользователь покупает от 1 до 10 продуктов
num_purchases = np.random.randint(1, 10)
for _ in range(num_purchases):
prod_id = np.random.randint(0, num_products)
purchases.append({
"user": f"user{user_id}",
"product": f"product{prod_id}",
"date": pd.Timestamp.now().strftime("%Y-%m-%d")
})

purchase_query = """
UNWIND $purchases AS purchase
MATCH (u:User {id: purchase.user}), (p:Product {id: purchase.product})
CREATE (u)-[:PURCHASED {date: purchase.date}]->(p)
"""
run_query(purchase_query, {"purchases": purchases})

print("База данных успешно инициализирована!")

def recommend_products_basic(user_id, limit=5):
"""
Простая рекомендация на основе покупок похожих пользователей
"""
query = """
MATCH (u:User {id: $user_id})-[:PURCHASED]->(p:Product)
MATCH (p)<-[:PURCHASED]-(similar:User)
MATCH (similar)-[:PURCHASED]->(recommendation:Product)
WHERE NOT (u)-[:PURCHASED]->(recommendation)
WITH recommendation, count(distinct similar) as freq
RETURN recommendation.id as product, freq
ORDER BY freq DESC
LIMIT $limit
"""
results = run_query(query, {"user_id": user_id, "limit": limit})
return [record["product"] for record in results]

# Тестирование базовой рекомендации
recommendations = recommend_products_basic("user1")
print(f"Рекомендации для user1: {recommendations}")

import networkx as nx

def build_product_similarity_graph():
"""
Строит граф схожести товаров на основе совместных покупок
"""
# Извлечение данных о покупках
query = """
MATCH (p:Product)<-[:PURCHASED]-(u:User)
RETURN p.id as product, collect(u.id) as users
"""
products_data = run_query(query)

# Создание графа схожести продуктов
G = nx.Graph()

# Добавление узлов (товаров)
for record in products_data:
G.add_node(record["product"])

# Добавление рёбер со значениями схожести (индекс Жаккара)
for i, prod1 in enumerate(products_data):
users1 = set(prod1["users"])
for prod2 in products_data[i+1:]:
users2 = set(prod2["users"])
if users1 and users2: # Проверка на непустые множества
similarity = len(users1.intersection(users2)) / len(users1.union(users2))
if similarity > 0: # Добавляем ребро только если есть схожесть
G.add_edge(prod1["product"], prod2["product"], weight=similarity)

return G

def recommend_products_advanced(user_id, limit=5):
"""
Улучшенная рекомендация с использованием NetworkX
"""
# Получаем текущие покупки пользователя
query = """
MATCH (u:User {id: $user_id})-[:PURCHASED]->(p:Product)
RETURN collect(p.id) as purchased
"""
purchased = run_query(query, {"user_id": user_id})[0]["purchased"]

# Строим граф схожести продуктов
G = build_product_similarity_graph()

# Ранжирование товаров для рекомендации
recommendations = {}
for product in purchased:
if product in G: # Проверяем, есть ли товар в графе
for neighbor, data in G[product].items():
if neighbor not in purchased:
if neighbor not in recommendations:
recommendations[neighbor] = 0
recommendations[neighbor] += data["weight"]

# Сортировка рекомендаций
sorted_recommendations = sorted(recommendations.items(), key=lambda x: x[1], reverse=True)
return [item[0] for item in sorted_recommendations[:limit]]

# Тестирование расширенной рекомендации
advanced_recommendations = recommend_products_advanced("user1")
print(f"Улучшенные рекомендации для user1: {advanced_recommendations}")

import pygraphviz as pgv

def visualize_recommendation_network(user_id):
"""
Визуализирует сеть рекомендаций для пользователя
"""
# Получаем текущие покупки пользователя
query = """
MATCH (u:User {id: $user_id})-[:PURCHASED]->(p:Product)
RETURN collect(p.id) as purchased
"""
purchased = run_query(query, {"user_id": user_id})[0]["purchased"]

# Получаем рекомендованные товары
recommended = recommend_products_advanced(user_id)

# Создаём граф для визуализации
G = pgv.AGraph(strict=False, directed=True)

# Добавляем узел пользователя
G.add_node(user_id, shape="box", style="filled", fillcolor="lightblue", fontsize=12)

# Добавляем узлы купленных товаров
for prod in purchased:
G.add_node(prod, shape="ellipse", style="filled", fillcolor="lightgreen")
G.add_edge(user_id, prod, color="blue", label="купил")

# Добавляем узлы рекомендованных товаров
for prod in recommended:
G.add_node(prod, shape="ellipse", style="filled", fillcolor="salmon")
G.add_edge(user_id, prod, color="red", style="dashed", label="рекомендуется")

# Получаем связи между рекомендациями и существующими покупками
similarity_graph = build_product_similarity_graph()
for rec in recommended:
for purch in purchased:
if similarity_graph.has_edge(rec, purch):
sim = similarity_graph.get_edge_data(rec, purch)["weight"]
if sim > 0.1: # Показываем только значимые связи
G.add_edge(purch, rec, color="purple", penwidth=sim*5, 
label=f"{sim:.2f}")

# Устанавливаем макет и сохраняем
G.layout(prog="fdp")
G.draw(f"{user_id}_recommendations.png")

return f"{user_id}_recommendations.png"

# Генерируем визуализацию
visualization_path = visualize_recommendation_network("user1")
print(f"Визуализация сохранена в: {visualization_path}")

# Закрытие соединения
driver.close()