使用EmbeddingGemma-300m构建知识图谱的完整指南-平芜编程栈

使用EmbeddingGemma-300m构建知识图谱的完整指南

如果你正在处理大量的文档、报告或者技术资料，想要从中提取出结构化的知识，让机器能够理解这些内容之间的关联，那么知识图谱可能是你正在寻找的解决方案。传统的知识图谱构建往往需要大量的人工标注和复杂的规则设计，但现在，有了像EmbeddingGemma-300m这样的嵌入模型，整个过程可以变得更加智能和自动化。

EmbeddingGemma-300m是Google推出的一个轻量级嵌入模型，只有3亿参数，但效果却相当不错。它能把文本转换成768维的向量，这些向量就像是文本的“数字指纹”，相似的文本会有相似的指纹。这个特性正好可以用来构建知识图谱——我们可以用它来识别文档中的实体、抽取实体之间的关系，然后把它们组织成一个结构化的知识网络。

这篇文章我会带你走一遍完整的流程，从环境准备到最终的知识图谱可视化，每一步都有具体的代码示例。即使你之前没怎么接触过知识图谱，跟着做下来也能搭建出一个可用的系统。

1. 环境准备与模型部署

首先我们需要把EmbeddingGemma-300m跑起来。这里我用Ollama来部署，因为它最简单，基本上就是一条命令的事情。

1.1 安装Ollama

如果你还没装Ollama，可以去官网下载对应系统的安装包，或者用命令行安装。这里以Linux/macOS为例：

# 下载安装脚本并执行 curl -fsSL https://ollama.com/install.sh | sh # 启动Ollama服务 ollama serve

Windows用户可以直接下载安装包，安装后会自动启动服务。

1.2 拉取EmbeddingGemma模型

Ollama服务起来之后，拉取模型就很简单了：

# 拉取EmbeddingGemma-300m模型 ollama pull embeddinggemma:300m # 如果想用量化版本节省显存，也可以拉取q8版本 ollama pull embeddinggemma:300m-qat-q8_0

量化版本会小一些，运行起来对硬件要求更低，但效果可能会有轻微损失。如果你的机器配置不错，用原版就行。

1.3 验证模型是否正常工作

拉取完成后，我们可以写个简单的Python脚本来测试一下：

import requests import json def test_embedding(): url = "http://localhost:11434/api/embed" # 测试数据 test_texts = ["苹果公司发布了新款iPhone", "微软推出了新的Windows系统"] payload = { "model": "embeddinggemma:300m", "input": test_texts } response = requests.post(url, json=payload) if response.status_code == 200: result = response.json() print(f"成功获取嵌入向量！") print(f"文本数量: {len(result['embeddings'])}") print(f"向量维度: {len(result['embeddings'][0])}") print(f"第一个向量的前5个值: {result['embeddings'][0][:5]}") else: print(f"请求失败: {response.status_code}") print(response.text) if __name__ == "__main__": test_embedding()

运行这个脚本，如果看到输出了向量信息，说明模型部署成功了。你会注意到每个文本都被转换成了一个768维的向量，这就是我们后面构建知识图谱的基础。

2. 知识图谱构建的核心步骤

知识图谱的构建通常包括三个主要步骤：实体识别、关系抽取和图谱构建。EmbeddingGemma在这三个步骤中都能发挥作用，特别是通过语义相似度来辅助我们完成这些任务。

2.1 实体识别：从文本中找出关键概念

实体识别就是要从一段文本中找出重要的名词或概念，比如人名、地名、组织机构、产品名等。传统方法可能需要训练专门的命名实体识别模型，但我们可以用EmbeddingGemma的语义理解能力来辅助这个过程。

一个实用的方法是先定义一些实体类型，然后让模型判断文本中的哪些部分属于这些类型。比如我们要处理科技新闻，可能关心的实体类型有：公司、产品、技术、人物等。

import requests import numpy as np from typing import List, Dict, Tuple class EntityExtractor: def __init__(self, ollama_url="http://localhost:11434/api/embed"): self.url = ollama_url self.model = "embeddinggemma:300m" # 预定义一些实体类型的描述 self.entity_types = { "company": "科技公司或企业，如Google、Apple、Microsoft", "product": "科技产品或软件，如iPhone、Windows、ChatGPT", "technology": "技术或框架，如人工智能、区块链、深度学习", "person": "科技领域的人物，如CEO、工程师、研究员" } # 预先计算实体类型描述的嵌入向量 self.type_embeddings = self._precompute_type_embeddings() def _precompute_type_embeddings(self): """预计算实体类型描述的嵌入向量""" type_descriptions = list(self.entity_types.values()) payload = { "model": self.model, "input": type_descriptions } response = requests.post(self.url, json=payload) result = response.json() # 构建类型到向量的映射 type_embeddings = {} for i, (type_name, _) in enumerate(self.entity_types.items()): type_embeddings[type_name] = np.array(result["embeddings"][i]) return type_embeddings def extract_entities(self, text: str, candidate_phrases: List[str]) -> List[Dict]: """ 从候选短语中识别实体 Args: text: 原始文本 candidate_phrases: 从文本中提取的候选短语列表 """ if not candidate_phrases: return [] # 获取所有候选短语的嵌入向量 payload = { "model": self.model, "input": candidate_phrases } response = requests.post(self.url, json=payload) result = response.json() phrase_embeddings = [np.array(emb) for emb in result["embeddings"]] entities = [] for i, phrase in enumerate(candidate_phrases): phrase_embedding = phrase_embeddings[i] # 计算与每个实体类型的相似度 similarities = {} for type_name, type_embedding in self.type_embeddings.items(): # 计算余弦相似度 similarity = np.dot(phrase_embedding, type_embedding) / ( np.linalg.norm(phrase_embedding) * np.linalg.norm(type_embedding) ) similarities[type_name] = similarity # 找出最相似的实体类型 best_type = max(similarities.items(), key=lambda x: x[1]) # 如果相似度超过阈值，认为是有效实体 if best_type[1] > 0.6: # 阈值可以根据实际情况调整 entities.append({ "text": phrase, "type": best_type[0], "similarity": float(best_type[1]), "position": text.find(phrase) # 在文本中的位置 }) return entities def find_candidate_phrases(self, text: str) -> List[str]: """ 简单的候选短语提取（实际项目中可以用更复杂的方法） 这里只是按名词短语简单分割 """ # 简单的基于标点和停用词的分割 import re # 移除标点，按空格分割 words = re.sub(r'[^\w\s]', ' ', text).split() # 简单的名词短语提取：连续的2-3个词组合 candidates = [] for i in range(len(words) - 1): # 两个词的短语 phrase = f"{words[i]} {words[i+1]}" candidates.append(phrase) # 三个词的短语 if i < len(words) - 2: phrase = f"{words[i]} {words[i+1]} {words[i+2]}" candidates.append(phrase) # 去重并过滤太短的短语 candidates = list(set(candidates)) candidates = [c for c in candidates if len(c.split()) >= 2 and len(c) > 3] return candidates[:20] # 限制数量，避免太多请求 # 使用示例 if __name__ == "__main__": extractor = EntityExtractor() # 示例文本 news_text = "Google近日发布了新的AI模型Gemini，由CEO Sundar Pichai亲自演示。该模型在多项测试中超越了GPT-4。" # 提取候选短语 candidates = extractor.find_candidate_phrases(news_text) print("候选短语:", candidates) # 识别实体 entities = extractor.extract_entities(news_text, candidates) print("\n识别到的实体:") for entity in entities: print(f" - {entity['text']} ({entity['type']}, 相似度: {entity['similarity']:.3f})")

这个实体识别器虽然简单，但已经能处理很多常见情况了。在实际项目中，你可以结合更专业的分词工具和命名实体识别模型，用EmbeddingGemma的语义信息作为补充。

2.2 关系抽取：发现实体之间的关联

识别出实体之后，下一步就是要找出它们之间的关系。比如“Google发布了Gemini”这句话中，“Google”和“Gemini”之间是“发布”关系。

关系抽取比实体识别更复杂，因为关系通常体现在动词和上下文语义中。我们可以用EmbeddingGemma来理解整个句子的语义，然后判断其中包含什么关系。

class RelationExtractor: def __init__(self, ollama_url="http://localhost:11434/api/embed"): self.url = ollama_url self.model = "embeddinggemma:300m" # 预定义一些关系类型和它们的描述 self.relation_types = { "develops": "开发或创建了某产品", "releases": "发布或推出了某产品", "acquires": "收购或并购了某公司", "competes_with": "与某公司竞争", "uses": "使用某技术或产品", "employs": "雇佣某人或某人在公司工作", "invests_in": "投资于某公司或项目" } # 预先计算关系描述的嵌入向量 self.relation_embeddings = self._precompute_relation_embeddings() def _precompute_relation_embeddings(self): """预计算关系描述的嵌入向量""" relation_descriptions = list(self.relation_types.values()) payload = { "model": self.model, "input": relation_descriptions } response = requests.post(self.url, json=payload) result = response.json() relation_embeddings = {} for i, (rel_name, _) in enumerate(self.relation_types.items()): relation_embeddings[rel_name] = np.array(result["embeddings"][i]) return relation_embeddings def extract_relations(self, text: str, entities: List[Dict]) -> List[Dict]: """ 从文本中抽取实体之间的关系 Args: text: 原始文本 entities: 识别出的实体列表 """ if len(entities) < 2: return [] relations = [] # 对每对实体，分析它们之间可能的关系 for i in range(len(entities)): for j in range(i + 1, len(entities)): entity1 = entities[i] entity2 = entities[j] # 提取两个实体之间的上下文 context = self._extract_context(text, entity1, entity2) if context: # 获取上下文的嵌入向量 payload = { "model": self.model, "input": [context] } response = requests.post(self.url, json=payload) result = response.json() context_embedding = np.array(result["embeddings"][0]) # 计算与每种关系类型的相似度 similarities = {} for rel_name, rel_embedding in self.relation_embeddings.items(): similarity = np.dot(context_embedding, rel_embedding) / ( np.linalg.norm(context_embedding) * np.linalg.norm(rel_embedding) ) similarities[rel_name] = similarity # 找出最可能的关系 best_relation = max(similarities.items(), key=lambda x: x[1]) if best_relation[1] > 0.5: # 关系阈值 relations.append({ "source": entity1["text"], "target": entity2["text"], "relation": best_relation[0], "confidence": float(best_relation[1]), "context": context }) return relations def _extract_context(self, text: str, entity1: Dict, entity2: Dict) -> str: """ 提取两个实体之间的上下文文本 """ pos1 = entity1["position"] pos2 = entity2["position"] # 确定起始和结束位置 start = min(pos1, pos2) end = max(pos1 + len(entity1["text"]), pos2 + len(entity2["text"])) # 扩展一些上下文 start = max(0, start - 20) end = min(len(text), end + 20) return text[start:end] def extract_relations_from_sentence(self, sentence: str, entities_in_sentence: List[str]) -> List[Dict]: """ 直接从句子中抽取关系（更简单的方法） """ relations = [] # 构建关系判断的提示 for i in range(len(entities_in_sentence)): for j in range(i + 1, len(entities_in_sentence)): entity1 = entities_in_sentence[i] entity2 = entities_in_sentence[j] # 构建描述两个实体关系的文本 relation_text = f"在句子'{sentence}'中，{entity1}和{entity2}之间有什么关系？" # 获取这个描述的嵌入 payload = { "model": self.model, "input": [relation_text] } response = requests.post(self.url, json=payload) result = response.json() relation_embedding = np.array(result["embeddings"][0]) # 计算与预定义关系的相似度 similarities = {} for rel_name, rel_embedding in self.relation_embeddings.items(): similarity = np.dot(relation_embedding, rel_embedding) / ( np.linalg.norm(relation_embedding) * np.linalg.norm(rel_embedding) ) similarities[rel_name] = similarity best_relation = max(similarities.items(), key=lambda x: x[1]) if best_relation[1] > 0.4: relations.append({ "source": entity1, "target": entity2, "relation": best_relation[0], "confidence": float(best_relation[1]) }) return relations # 使用示例 if __name__ == "__main__": # 创建关系抽取器 relation_extractor = RelationExtractor() # 示例文本和实体 sample_text = "微软宣布收购GitHub，这是科技行业的一次重大并购。" sample_entities = [ {"text": "微软", "type": "company", "position": 0}, {"text": "GitHub", "type": "company", "position": 6} ] # 抽取关系 relations = relation_extractor.extract_relations(sample_text, sample_entities) print("抽取到的关系:") for rel in relations: print(f" {rel['source']} --[{rel['relation']}]--> {rel['target']}") print(f" 置信度: {rel['confidence']:.3f}, 上下文: {rel['context']}")

关系抽取是知识图谱构建中最有挑战性的部分，因为自然语言中的关系表达非常多样。上面的方法基于语义相似度，虽然不能覆盖所有情况，但对于很多常见的科技新闻、技术文档来说，效果已经不错了。

2.3 图谱构建与嵌入存储

有了实体和关系，我们就可以构建知识图谱了。在实际应用中，我们还需要把文本的嵌入向量存储起来，方便后续的搜索和推理。

这里我用Neo4j作为图数据库来存储知识图谱，用Chroma或FAISS来存储嵌入向量。这两个都是开源工具，安装和使用都比较简单。

from neo4j import GraphDatabase import chromadb from chromadb.config import Settings import numpy as np class KnowledgeGraphBuilder: def __init__(self, neo4j_uri="bolt://localhost:7687", neo4j_user="neo4j", neo4j_password="password"): """ 初始化知识图谱构建器 Args: neo4j_uri: Neo4j数据库地址 neo4j_user: 用户名 neo4j_password: 密码 """ # 连接Neo4j self.driver = GraphDatabase.driver(neo4j_uri, auth=(neo4j_user, neo4j_password)) # 初始化ChromaDB用于存储嵌入向量 self.chroma_client = chromadb.Client(Settings( chroma_db_impl="duckdb+parquet", persist_directory="./chroma_db" )) # 创建或获取集合 self.collection = self.chroma_client.get_or_create_collection( name="entity_embeddings", metadata={"description": "实体嵌入向量存储"} ) # Ollama连接信息 self.ollama_url = "http://localhost:11434/api/embed" self.model = "embeddinggemma:300m" def create_entity(self, entity_data: Dict): """ 在Neo4j中创建实体节点 """ with self.driver.session() as session: # 创建实体节点 query = """ MERGE (e:Entity {name: $name}) SET e.type = $type, e.source_text = $source_text, e.created_at = timestamp() RETURN e """ result = session.run(query, name=entity_data["text"], type=entity_data["type"], source_text=entity_data.get("source_text", "")) # 获取实体的嵌入向量 embedding = self._get_embedding(entity_data["text"]) # 存储嵌入向量到ChromaDB self.collection.add( embeddings=[embedding.tolist()], documents=[entity_data["text"]], metadatas=[{"type": entity_data["type"], "source": "extracted"}], ids=[f"entity_{hash(entity_data['text'])}"] ) return result.single() def create_relation(self, relation_data: Dict): """ 在Neo4j中创建关系 """ with self.driver.session() as session: query = """ MATCH (source:Entity {name: $source_name}) MATCH (target:Entity {name: $target_name}) MERGE (source)-[r:RELATES_TO {type: $relation_type}]->(target) SET r.confidence = $confidence, r.context = $context, r.created_at = timestamp() RETURN r """ result = session.run(query, source_name=relation_data["source"], target_name=relation_data["target"], relation_type=relation_data["relation"], confidence=relation_data["confidence"], context=relation_data.get("context", "")) return result.single() def _get_embedding(self, text: str) -> np.ndarray: """获取文本的嵌入向量""" import requests payload = { "model": self.model, "input": [text] } response = requests.post(self.ollama_url, json=payload) result = response.json() return np.array(result["embeddings"][0]) def find_similar_entities(self, query: str, top_k: int = 5) -> List[Dict]: """ 查找与查询文本相似的实体 """ # 获取查询文本的嵌入 query_embedding = self._get_embedding(query) # 在ChromaDB中搜索相似实体 results = self.collection.query( query_embeddings=[query_embedding.tolist()], n_results=top_k ) similar_entities = [] for i in range(len(results["documents"][0])): similar_entities.append({ "entity": results["documents"][0][i], "metadata": results["metadatas"][0][i], "distance": results["distances"][0][i] }) return similar_entities def expand_knowledge_graph(self, query: str): """ 基于查询扩展知识图谱 """ # 查找相似实体 similar_entities = self.find_similar_entities(query) if not similar_entities: print("未找到相关实体") return # 对每个相似实体，查找其在图谱中的邻居 with self.driver.session() as session: for entity_info in similar_entities: entity_name = entity_info["entity"] # 查找该实体的邻居 query = """ MATCH (e:Entity {name: $entity_name})-[r]-(neighbor) RETURN e.name as entity, type(r) as relation, neighbor.name as neighbor, r.confidence as confidence LIMIT 10 """ result = session.run(query, entity_name=entity_name) print(f"\n实体 '{entity_name}' 的相关信息:") for record in result: print(f" {record['entity']} --[{record['relation']}]--> {record['neighbor']}") def close(self): """关闭连接""" self.driver.close() self.chroma_client.persist() # 使用示例 if __name__ == "__main__": # 初始化知识图谱构建器（需要先启动Neo4j） kg_builder = KnowledgeGraphBuilder() # 示例实体和关系数据 entities = [ {"text": "Google", "type": "company", "source_text": "Google发布了Gemini"}, {"text": "Gemini", "type": "product", "source_text": "Google发布了Gemini"}, {"text": "Sundar Pichai", "type": "person", "source_text": "CEO Sundar Pichai演示"} ] relations = [ {"source": "Google", "target": "Gemini", "relation": "releases", "confidence": 0.85}, {"source": "Google", "target": "Sundar Pichai", "relation": "employs", "confidence": 0.78} ] # 创建实体节点 print("创建实体节点...") for entity in entities: kg_builder.create_entity(entity) print(f" 已创建实体: {entity['text']}") # 创建关系 print("\n创建关系...") for relation in relations: kg_builder.create_relation(relation) print(f" 已创建关系: {relation['source']} -> {relation['target']}") # 搜索相似实体 print("\n搜索与'人工智能公司'相似的实体:") similar = kg_builder.find_similar_entities("人工智能公司") for item in similar: print(f" {item['entity']} (类型: {item['metadata']['type']}, 距离: {item['distance']:.3f})") # 扩展知识图谱 print("\n扩展知识图谱查询:") kg_builder.expand_knowledge_graph("科技公司产品") kg_builder.close()

这个知识图谱构建器把实体和关系存储到Neo4j中，把嵌入向量存储到ChromaDB中。这样既可以利用图数据库的强大查询能力，又能利用向量数据库的相似性搜索功能。

3. 完整流程实战：构建科技新闻知识图谱

现在我们把上面的各个部分组合起来，构建一个完整的科技新闻知识图谱系统。我会用一个实际的例子来演示整个流程。

3.1 数据准备

假设我们有一些科技新闻文本，我们要从中提取知识。这里我准备了一些示例数据：

tech_news = [ { "title": "Google发布新一代AI模型Gemini", "content": "Google近日发布了新一代AI模型Gemini，该模型在多模态理解方面表现突出，被认为是对OpenAI GPT-4的有力竞争。CEO Sundar Pichai在发布会上亲自演示了模型能力。", "source": "科技新闻1", "date": "2024-01-15" }, { "title": "微软完成对GitHub的收购", "content": "微软宣布以75亿美元完成对代码托管平台GitHub的收购，这是微软在开发者工具领域的重要布局。Satya Nadella表示这将加速微软的AI开发进程。", "source": "科技新闻2", "date": "2024-01-10" }, { "title": "苹果推出Vision Pro头显", "content": "苹果公司发布了混合现实头显Vision Pro，该产品采用了先进的眼动追踪技术和空间计算能力。Tim Cook称这是苹果在AR领域的重要突破。", "source": "科技新闻3", "date": "2024-01-05" } ]

3.2 完整的处理流程

class TechNewsKnowledgeGraph: def __init__(self): # 初始化各个组件 self.entity_extractor = EntityExtractor() self.relation_extractor = RelationExtractor() self.kg_builder = KnowledgeGraphBuilder() # 统计信息 self.stats = { "total_news": 0, "entities_extracted": 0, "relations_extracted": 0 } def process_news(self, news_item: Dict): """处理单条新闻""" print(f"\n处理新闻: {news_item['title']}") # 提取实体 candidates = self.entity_extractor.find_candidate_phrases( news_item['content'] ) entities = self.entity_extractor.extract_entities( news_item['content'], candidates ) print(f" 提取到 {len(entities)} 个实体:") for entity in entities: print(f" - {entity['text']} ({entity['type']})") # 添加来源信息 entity["source_text"] = news_item['content'] # 保存到知识图谱 self.kg_builder.create_entity(entity) # 提取关系 relations = self.relation_extractor.extract_relations( news_item['content'], entities ) print(f" 提取到 {len(relations)} 个关系:") for relation in relations: print(f" - {relation['source']} -> {relation['target']} ({relation['relation']})") # 保存到知识图谱 self.kg_builder.create_relation(relation) # 更新统计 self.stats["total_news"] += 1 self.stats["entities_extracted"] += len(entities) self.stats["relations_extracted"] += len(relations) def process_batch(self, news_list: List[Dict]): """批量处理新闻""" print("开始处理科技新闻...") print("=" * 50) for news in news_list: self.process_news(news) print("\n" + "=" * 50) print("处理完成！") print(f"总计处理新闻: {self.stats['total_news']} 条") print(f"提取实体: {self.stats['entities_extracted']} 个") print(f"提取关系: {self.stats['relations_extracted']} 个") def query_knowledge(self, question: str): """查询知识图谱""" print(f"\n查询: {question}") print("-" * 30) # 先找相似实体 similar_entities = self.kg_builder.find_similar_entities(question) if similar_entities: print("相关实体:") for entity in similar_entities[:3]: # 显示前3个 print(f" • {entity['entity']} ({entity['metadata']['type']})") # 扩展查询 self.kg_builder.expand_knowledge_graph(question) else: print("未找到相关信息") def close(self): """关闭所有连接""" self.kg_builder.close() # 运行完整流程 if __name__ == "__main__": # 创建处理器 processor = TechNewsKnowledgeGraph() try: # 处理新闻数据 processor.process_batch(tech_news) # 查询示例 print("\n\n知识图谱查询示例:") print("=" * 50) processor.query_knowledge("Google发布了什么产品？") processor.query_knowledge("科技公司CEO") processor.query_knowledge("AI模型竞争") finally: # 关闭连接 processor.close()

运行这个完整的流程，你会看到系统如何从原始新闻文本中提取实体和关系，构建知识图谱，然后支持各种查询。整个过程都是自动化的，只需要提供原始文本就行。

3.3 可视化知识图谱

构建好的知识图谱可以用各种工具进行可视化。这里我推荐用Neo4j自带的浏览器界面，或者用Python的networkx和matplotlib库。

import networkx as nx import matplotlib.pyplot as plt from neo4j import GraphDatabase def visualize_knowledge_graph(uri="bolt://localhost:7687", user="neo4j", password="password"): """可视化知识图谱""" # 连接Neo4j driver = GraphDatabase.driver(uri, auth=(user, password)) # 查询图谱数据 with driver.session() as session: query = """ MATCH (e1:Entity)-[r:RELATES_TO]->(e2:Entity) RETURN e1.name as source, e2.name as target, r.type as relation, r.confidence as confidence LIMIT 50 """ result = session.run(query) # 创建NetworkX图 G = nx.DiGraph() # 添加节点和边 for record in result: source = record["source"] target = record["target"] relation = record["relation"] confidence = record["confidence"] # 添加节点 G.add_node(source) G.add_node(target) # 添加边（带关系标签） G.add_edge(source, target, label=relation, weight=confidence) driver.close() # 绘制图形 plt.figure(figsize=(12, 8)) # 使用spring布局 pos = nx.spring_layout(G, k=1, iterations=50) # 绘制节点 nx.draw_networkx_nodes(G, pos, node_size=500, node_color='lightblue', alpha=0.8) # 绘制边 edges = G.edges() weights = [G[u][v]['weight'] for u, v in edges] nx.draw_networkx_edges(G, pos, edgelist=edges, width=[w*3 for w in weights], # 宽度表示置信度 edge_color='gray', alpha=0.6) # 绘制节点标签 nx.draw_networkx_labels(G, pos, 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("科技新闻知识图谱", fontsize=16) plt.axis('off') plt.tight_layout() plt.show() # 输出一些统计信息 print(f"图谱包含 {G.number_of_nodes()} 个节点") print(f"图谱包含 {G.number_of_edges()} 条边") print("\n节点度中心性（最重要的节点）:") degree_centrality = nx.degree_centrality(G) for node, centrality in sorted(degree_centrality.items(), key=lambda x: x[1], reverse=True)[:5]: print(f" {node}: {centrality:.3f}") # 运行可视化 if __name__ == "__main__": visualize_knowledge_graph()

这个可视化代码会从Neo4j中读取知识图谱数据，然后用networkx绘制出来。节点的大小和边的宽度可以反映实体和关系的重要性，让你一眼就能看出整个知识图谱的结构。

4. 优化建议与实践经验

在实际使用EmbeddingGemma构建知识图谱的过程中，我总结了一些优化建议和经验，分享给你：

4.1 性能优化

EmbeddingGemma-300m虽然不大，但处理大量文本时还是需要注意性能。根据我在实际项目中的经验，有几点可以优化：

批量处理：尽量把多个文本一起发送给Ollama API，而不是一个一个地请求。批量处理可以显著提高吞吐量。
缓存机制：相同的文本不需要重复计算嵌入向量。可以建立一个缓存系统，把计算过的向量存起来，下次直接使用。
异步处理：如果处理大量文档，可以用异步IO来并发请求，充分利用网络带宽。

import asyncio import aiohttp from typing import List class AsyncEmbeddingClient: def __init__(self, base_url="http://localhost:11434/api/embed"): self.base_url = base_url self.model = "embeddinggemma:300m" async def get_embeddings_batch(self, texts: List[str], batch_size: int = 32): """异步批量获取嵌入向量""" embeddings = [] # 分批处理 for i in range(0, len(texts), batch_size): batch = texts[i:i + batch_size] async with aiohttp.ClientSession() as session: payload = { "model": self.model, "input": batch } async with session.post(self.base_url, json=payload) as response: if response.status == 200: result = await response.json() embeddings.extend(result["embeddings"]) else: # 出错时用None填充 embeddings.extend([None] * len(batch)) # 稍微休息一下，避免压垮服务 await asyncio.sleep(0.1) return embeddings

4.2 质量提升

知识图谱的质量很大程度上取决于实体识别和关系抽取的准确性。有几种方法可以提升质量：

领域适配：EmbeddingGemma是通用模型，如果你处理的是特定领域（比如医疗、法律），可以考虑用领域内的数据对模型进行微调，或者至少调整实体类型和关系类型的描述，让它们更符合领域特点。
后处理规则：结合一些规则来修正模型的输出。比如，如果识别出的“公司”实体以“公司”或“科技”结尾，可能更可信。
人工审核：对于重要的知识图谱，可以设计一个人工审核流程，让专家对自动提取的结果进行验证和修正。