isage-middleware 0.1.4__py3-none-any.whl → 0.1.5.1__py3-none-any.whl

sage/middleware/services/graph/examples/graph_demo.py

@@ -1,178 +0,0 @@
-"""
-Graph Service 使用示例
-展示如何使用Graph微服务进行知识图谱构建和查询
-"""
-from sage.core.api.local_environment import LocalEnvironment
-from sage.middleware.services.graph import create_graph_service_factory
-
-
-def test_graph_service():
-    """测试Graph服务基本功能"""
-    print("🚀 Graph Service Demo")
-    print("=" * 50)
-    
-    # 创建环境
-    env = LocalEnvironment("graph_service_demo")
-    
-    # 注册Graph服务 - 内存后端
-    graph_factory = create_graph_service_factory(
-        service_name="demo_graph_service",
-        backend_type="memory",
-        max_nodes=10000,
-        max_relationships=50000
-    )
-    # 使用服务工厂注册（与 SAGE Kernel 的 ServiceFactory 对齐）
-    env.register_service_factory("demo_graph_service", graph_factory)
-    
-    print("✅ Graph Service registered with memory backend")
-    print("   - Max nodes: 10,000")
-    print("   - Max relationships: 50,000")
-    
-    # 模拟知识图谱构建
-    print("\n📝 Knowledge Graph Operations Demo:")
-    
-    # 创建实体节点
-    entities = [
-        {"id": "person_1", "labels": ["Person"], "properties": {"name": "Alice", "age": 30}},
-        {"id": "person_2", "labels": ["Person"], "properties": {"name": "Bob", "age": 25}},
-        {"id": "company_1", "labels": ["Company"], "properties": {"name": "TechCorp", "founded": 2010}},
-        {"id": "skill_1", "labels": ["Skill"], "properties": {"name": "Python", "category": "Programming"}},
-        {"id": "skill_2", "labels": ["Skill"], "properties": {"name": "AI", "category": "Technology"}}
-    ]
-    
-    print(f"  add_nodes({len(entities)} entities) -> ✅ Added 5 nodes")
-    for entity in entities:
-        print(f"    - {entity['labels'][0]}: {entity['properties']['name']}")
-    
-    # 创建关系
-    relationships = [
-        {"from_node": "person_1", "to_node": "company_1", "rel_type": "WORKS_AT", "properties": {"since": 2020}},
-        {"from_node": "person_2", "to_node": "company_1", "rel_type": "WORKS_AT", "properties": {"since": 2021}},
-        {"from_node": "person_1", "to_node": "skill_1", "rel_type": "HAS_SKILL", "properties": {"level": "Expert"}},
-        {"from_node": "person_1", "to_node": "skill_2", "rel_type": "HAS_SKILL", "properties": {"level": "Intermediate"}},
-        {"from_node": "person_2", "to_node": "skill_1", "rel_type": "HAS_SKILL", "properties": {"level": "Beginner"}},
-        {"from_node": "person_1", "to_node": "person_2", "rel_type": "COLLEAGUE", "properties": {"since": 2021}}
-    ]
-    
-    print(f"  add_relationships({len(relationships)} relations) -> ✅ Added 6 relationships")
-    for rel in relationships:
-        print(f"    - {rel['from_node']} --[{rel['rel_type']}]--> {rel['to_node']}")
-    
-    # 图查询示例
-    print("\n🔍 Graph Query Examples:")
-    
-    queries = [
-        {
-            "name": "查找Alice的同事",
-            "description": "MATCH (alice:Person {name: 'Alice'})-[:COLLEAGUE]->(colleague) RETURN colleague",
-            "result": "Bob"
-        },
-        {
-            "name": "查找TechCorp的员工",
-            "description": "MATCH (person:Person)-[:WORKS_AT]->(company:Company {name: 'TechCorp'}) RETURN person",
-            "result": "Alice, Bob"
-        },
-        {
-            "name": "查找Python专家",
-            "description": "MATCH (person:Person)-[r:HAS_SKILL]->(skill:Skill {name: 'Python'}) WHERE r.level = 'Expert' RETURN person",
-            "result": "Alice"
-        },
-        {
-            "name": "查找Alice的技能图谱",
-            "description": "MATCH (alice:Person {name: 'Alice'})-[:HAS_SKILL]->(skill:Skill) RETURN skill",
-            "result": "Python (Expert), AI (Intermediate)"
-        }
-    ]
-    
-    for query in queries:
-        print(f"  📊 {query['name']}:")
-        print(f"      Query: {query['description']}")
-        print(f"      Result: {query['result']}")
-    
-    print("\n💡 Graph Service Features:")
-    print("   - 知识图谱构建和管理")
-    print("   - 复杂图查询")
-    print("   - 图算法 (路径查找、社区发现)")
-    print("   - 实体关系推理")
-    print("   - 图可视化支持")
-
-
-def test_graph_algorithms():
-    """演示图算法功能"""
-    print("\n🧮 Graph Algorithms:")
-    
-    algorithms = [
-        {
-            "name": "最短路径",
-            "function": "shortest_path(person_1, person_2)",
-            "description": "查找两个实体间的最短关系路径",
-            "result": "person_1 -> company_1 <- person_2"
-        },
-        {
-            "name": "邻居发现",
-            "function": "get_neighbors(person_1, depth=2)",
-            "description": "查找指定深度内的所有相关实体",
-            "result": "company_1, skill_1, skill_2, person_2"
-        },
-        {
-            "name": "社区检测",
-            "function": "detect_communities()",
-            "description": "发现图中的紧密连接社区",
-            "result": "Community 1: [person_1, person_2, company_1]"
-        },
-        {
-            "name": "中心性分析",
-            "function": "centrality_analysis()",
-            "description": "分析节点在图中的重要性",
-            "result": "company_1: highest centrality (连接最多)"
-        }
-    ]
-    
-    for algo in algorithms:
-        print(f"  🔄 {algo['name']}: {algo['description']}")
-        print(f"      调用: {algo['function']}")
-        print(f"      结果: {algo['result']}")
-
-
-def test_graph_applications():
-    """演示Graph服务的应用场景"""
-    print("\n🎯 Graph Service Applications:")
-    
-    applications = [
-        {
-            "name": "推荐系统",
-            "scenario": "基于用户-物品-属性图进行协同过滤推荐",
-            "entities": ["User", "Item", "Category", "Tag"],
-            "relationships": ["LIKES", "BELONGS_TO", "HAS_TAG", "SIMILAR_TO"]
-        },
-        {
-            "name": "知识问答",
-            "scenario": "构建领域知识图谱，支持复杂问答推理",
-            "entities": ["Concept", "Entity", "Relation", "Attribute"],
-            "relationships": ["IS_A", "PART_OF", "RELATED_TO", "HAS_PROPERTY"]
-        },
-        {
-            "name": "社交网络分析",
-            "scenario": "分析用户关系，发现社区和影响者",
-            "entities": ["User", "Post", "Topic", "Event"],
-            "relationships": ["FOLLOWS", "POSTS", "MENTIONS", "ATTENDS"]
-        },
-        {
-            "name": "欺诈检测",
-            "scenario": "通过异常图模式检测可疑行为",
-            "entities": ["Account", "Transaction", "Device", "Location"],
-            "relationships": ["TRANSFERS", "USES", "LOCATED_AT", "LINKED_TO"]
-        }
-    ]
-    
-    for app in applications:
-        print(f"  📈 {app['name']}: {app['scenario']}")
-        print(f"      实体类型: {', '.join(app['entities'])}")
-        print(f"      关系类型: {', '.join(app['relationships'])}")
-
-
-if __name__ == "__main__":
-    test_graph_service()
-    test_graph_algorithms()
-    test_graph_applications()
-    print("\n🎯 Graph Service demo completed!")

sage/middleware/services/graph/graph_index.py

@@ -1,194 +0,0 @@
-import collections
-import uuid
-import networkx as nx
-import matplotlib.pyplot as plt
-#from sage_memory.search_engine.graph_index.base_graph_index import BaseGraphIndex
-
-class KnowledgeGraphIndex():
-    """
-    Simple knowledge graph storage.
-    基于图的知识存储器。
-    """
-
-    def __init__(self):
-        # 初始化成员变量
-        self.qid2name = collections.defaultdict(str)  # QID ---> entity name
-        self.triples = collections.defaultdict(set)  # (head, rel) ---> set(tail, sentence)
-        self.qid_relations = collections.defaultdict(set)  # QID ---> set(rel)
-
-    def construct_graph(self, batch):
-        """
-        从批次数据中构建知识图谱
-        输入格式: batch = [["head", "relation", "tail"], ...]
-        """
-        for head, relation, tail in batch:
-            # 构造三元组的句子
-            sentence = f"{head} --[{relation}]--> {tail}"
-            # 插入三元组
-            self.insert_edge(head, relation, tail, sentence)
-
-    def insert_edge(self, head, relation, tail, sentence):
-        """
-        插入一条新的边 (head, relation, tail)
-        """
-        head_id=uuid.uuid5(uuid.NAMESPACE_DNS, head)
-        tail_id=uuid.uuid5(uuid.NAMESPACE_DNS, tail)
-        
-        # 添加 head 和 tail 的名称映射
-        if head_id not in self.qid2name:
-            self.qid2name[head_id] = head
-        if tail_id not in self.qid2name:
-            self.qid2name[tail_id] = tail
-
-        # 检查 triples 中是否已存在该三元组
-        if (tail_id, sentence) not in self.triples[(head_id, relation)]:
-            self.triples[(head_id, relation)].add((tail_id, sentence))
-
-        # 检查 qid_relations 中是否已存在该关系
-        if relation not in self.qid_relations[head_id]:
-            self.qid_relations[head_id].add(relation)
-
-    
-    def delete_edge(self, head, relation, tail):
-        """
-        删除知识图谱中的一条边 (head, relation, tail)
-        """
-        # 生成唯一的 ID
-        head_id = uuid.uuid5(uuid.NAMESPACE_DNS, head)
-        tail_id = uuid.uuid5(uuid.NAMESPACE_DNS, tail)
-        # 从 triples 中删除对应的三元组
-        if (head_id, relation) in self.triples:
-            self.triples[(head_id, relation)] = {
-                t for t in self.triples[(head_id, relation)] if t[0] != tail_id
-            }
-            # 如果关系为空，则从 qid_relations 中移除
-            if not self.triples[(head_id, relation)]:
-                del self.triples[(head_id, relation)]
-                self.qid_relations[head_id].remove(relation)
-    
-    def modify_edge(self, head, relation, tail, new_tail):
-        """
-        修改知识图谱中的一条边 (head, relation, tail) 为 (head, relation, new_tail)
-        """
-        # 生成唯一的 ID
-        head_id = uuid.uuid5(uuid.NAMESPACE_DNS, head)
-        tail_id = uuid.uuid5(uuid.NAMESPACE_DNS, tail)
-        new_tail_id = uuid.uuid5(uuid.NAMESPACE_DNS, new_tail)
-
-        # 检查是否存在该关系
-        if (head_id, relation) in self.triples:
-            # 获取当前关系中的所有尾节点
-            current_tails = self.triples[(head_id, relation)]
-            
-
-            # 检查是否存在指定的尾节点
-            tail_exists = False
-            for tail_id_in_graph, sentence in current_tails:
-                if tail_id_in_graph == tail_id:
-                    tail_exists = True
-                    # 修改尾节点为 new_tail
-                    current_tails.remove((tail_id_in_graph, sentence))
-                    new_sentence = f"{head} --[{relation}]--> {new_tail}"
-                    current_tails.add((new_tail_id, new_sentence))
-                    if new_tail_id not in self.qid2name:
-                        self.qid2name[new_tail_id] = new_tail
-                    break
-
-            if not tail_exists:
-                print(f"Edge ({head}, {relation}, {tail}) does not exist.")
-                return
-        else:
-            print(f"Relation ({head}, {relation}) does not exist in the graph.")
-
-
-    def clear_relation(self, head, relation):
-        head_id = uuid.uuid5(uuid.NAMESPACE_DNS, head)
-        if (head_id, relation) in self.triples:
-            del self.triples[(head_id, relation)]
-            self.qid_relations[head_id].remove(relation)
-
-    def get_neighbors(self, entity):
-        neighbors = set()
-        head_id = uuid.uuid5(uuid.NAMESPACE_DNS, entity)
-        for relation in self.qid_relations[head_id]:
-            for tail, _ in self.triples[(head_id, relation)]:
-                neighbors.add((relation, tail))
-        for relation, tail in neighbors:
-            print(f"Relation: {relation}, Tail: {self.qid2name[tail]}")
-        return neighbors
-    
-
-    def print_graph(self):
-        """
-        打印知识图谱的内容
-        """
-        print("Knowledge Graph:")
-        for (head_id, relation), tails in self.triples.items():
-            for tail_id, sentence in tails:
-                print(f"{self.qid2name[head_id]} --[{relation}]--> {self.qid2name[tail_id]}")
-
-
-    def visualize_knowledge_graph(self):
-        """
-        可视化知识图谱
-        """
-        # 创建一个有向图
-        G = nx.DiGraph()
-
-        # 添加节点和边
-        for (head_id, relation), tails in self.triples.items():  # 使用 self 访问成员变量
-            head_name = self.qid2name[head_id]
-            for tail_id, sentence in tails:
-                tail_name = self.qid2name[tail_id]
-                G.add_edge(head_name, tail_name, label=relation)
-
-        # 绘制图形
-        pos = nx.spring_layout(G)  # 使用 spring 布局
-        plt.figure(figsize=(12, 8))
-
-        # 绘制节点和边
-        nx.draw(G, pos, with_labels=True, node_size=3000, node_color="lightblue", font_size=10, font_weight="bold")
-        
-        # 绘制边上的标签
-        edge_labels = nx.get_edge_attributes(G, 'label')
-        nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels, font_size=8)
-
-        # 显示图形
-        plt.title("Knowledge Graph Visualization", fontsize=16)
-        plt.savefig("knowledge_graph.png")  # 保存图形到文件
-
-if __name__ == "__main__":
-    # 创建 KnowledgeGraphStorage 实例
-    kg_storage = KnowledgeGraphIndex()
-
-    # 定义测试数据
-    batch = [
-        ["Trump", "president_of", "USA"],
-        ["Trump", "fans_of", "CR7"],
-        ["Trump", "fans_of", "Mask"],
-        ["CR7", "rival_of", "Messi"],
-        ["CR7", "play_for", "Manchester United"],
-        ["CR7", "born_in", "Portugal"],
-        ["Manchester United", "located_in", "England"],
-    ]
-
-    # 构建知识图谱
-    kg_storage.construct_graph(batch)
-
-    # 打印知识图谱内容
-    print("测试输出:")
-    kg_storage.print_graph()
-    print()
-
-    print("CR7效力的球队发生了变化，需要修改知识图谱中的边:")
-    kg_storage.modify_edge("CR7", "play_for", "Manchester United", "Al-Nassr FC")
-    kg_storage.print_graph()
-    print()
-
-    print("Trump和Mask闹掰了，需要删除知识图谱中的边:")
-    kg_storage.delete_edge("Trump", "fans_of", "Mask")
-    kg_storage.print_graph()
-
-    kg_storage.get_neighbors("CR7")
-    # 可视化知识图谱
-    kg_storage.visualize_knowledge_graph()