企业官网建设流程全解析

简介：本资源是一套基于Python实现PDF智能处理与知识图谱应用的高分毕业设计源码，面向计算机、电子信息、数学等专业的本科生与研究生，解决非结构化PDF文档的识别、语义信息抽取、知识建模及关联检索等核心问题，适用于课程设计、期末大作业与毕设参考。压缩包共119个文件，含47个核心Python脚本（覆盖PDF解析、OCR调用、实体关系抽取、图谱构建与Neo4j集成）、15个前端JS/Vue组件（支持知识图谱可视化与交互式检索）、9个JSON/JSONL配置与标注数据、5个PNG示意图及SQLite3本地知识库等，整体体积仅4.79MB，结构紧凑、模块解耦清晰。目前已有962人学习下载，资源提供完整可运行工程，包含从PDF文本提取→三元组生成→图谱存储→自然语言问句检索的全链路实现，附带README说明、Webpack前端构建配置及标准化项目目录，便于理解架构逻辑与二次开发。

1. PDF文档智能解析不是OCR截图+关键词搜索：它要让非结构化PDF变成可推理、可检索、可关联的知识网络

你有没有试过打开一份几十页的招标文件、技术白皮书或科研报告PDF，想快速定位“项目周期”“验收标准”“接口协议版本”这些关键信息？手动翻页、Ctrl+F、复制粘贴——这根本不是分析，是体力劳动。更糟的是，当同一份PDF里“甲方”“采购方”“委托单位”混用，“V2.3”“v2.3”“版本2.3”并存，关键词搜索直接失效。而所谓“高分毕设”里常被忽略的核心矛盾是：PDF不是图片，也不是纯文本；它是排版逻辑、语义层级、跨页表格、嵌入图表与文字混排的复合体。直接扔给通用OCR或PDF文本提取库（如PyPDF2），90%的标题层级丢失、表格错行、公式乱码、页眉页脚污染正文——后续所有知识图谱构建都建在流沙上。本方案不走“先转文本再NLP”的老路，而是用Python构建一条端到端链路：从PDF原始布局理解出发，精准恢复语义结构 → 基于规则+轻量模型做领域适配的信息抽取 → 将实体与关系注入图数据库 → 实现基于图结构的语义检索。适合需要处理合同、标书、年报、论文等专业PDF的开发者、数据工程师和毕业设计学生——它不追求“一键生成”，但每一步都可调试、可解释、可落地。

2. 从PDF原始布局重建语义结构：为什么不能只用pdfplumber或PyMuPDF？

PDF解析的起点错误，后面全盘皆输。很多同学一上来就pip install PyPDF2，调用.extract_text()，发现中文乱码、表格变段落、页眉混进正文，然后疯狂调参、换库、加正则——这是典型的“把问题当故障修，而不是当系统设计”。真正可靠的PDF结构还原，必须同时满足三个条件：保留原始坐标信息以识别布局关系、区分文本块类型（标题/正文/表格/页脚）、支持跨页内容聚合。我们选型pdfplumber而非更轻量的PyPDF2，核心原因在于其Page.chars和Page.rects底层暴露了PDF渲染指令级数据，让我们能自己定义“什么是标题”（比如：字体大小>14pt且居中+下有横线）、“什么是表格边界”（连续矩形框构成的网格）。而PyMuPDF虽快，但默认get_text("text")会抹平所有布局线索，get_text("dict")又过于原始，需大量自定义解析逻辑。

2.1 用pdfplumber提取带坐标的文本块与表格结构

import pdfplumber def extract_layout_structured(pdf_path: str, page_num: int = 0) -> dict: with pdfplumber.open(pdf_path) as pdf: page = pdf.pages[page_num] # 提取所有字符级信息（含x0,x1,y0,y1,fontname,size,text） chars = page.chars # 提取所有矩形框（用于识别表格线、分隔线） rects = page.rects # 提取所有文本块（已按视觉位置聚类，比chars更粗粒度） words = page.extract_words( x_tolerance=2, # 水平方向合并阈值（像素） y_tolerance=2, # 垂直方向合并阈值 keep_blank_chars=True, use_text_flow=True # 启用文本流模式，更好处理多栏 ) return { "words": words, # [{'text': '第一章', 'x0': 100, 'top': 50, ...}, ...] "rects": rects, # 表格线、边框等矩形区域 "chars": chars # 字符级原始数据，用于精细分析 } # 示例：打印第0页前5个文本块的位置与内容 layout = extract_layout_structured("sample.pdf", 0) for i, w in enumerate(layout["words"][:5]): print(f"[{i}] '{w['text']}' @ ({w['x0']:.1f}, {w['top']:.1f}) size={w['height']:.1f}")

逻辑说明：extract_words()返回的每个字典包含x0(左边界)、top(上边界)、height、text等字段。x0和top是PDF坐标系（原点在左上角），单位为磅（point），1pt≈0.35mm。y_tolerance=2意味着垂直距离小于2pt的字符会被合并成一个词——这对处理PDF中因抗锯齿导致的字符微偏移至关重要。use_text_flow=True启用后，pdfplumber会尝试按阅读顺序（而非绘制顺序）重组文本，对多栏文档效果显著提升。

2.2 基于坐标与字体特征识别标题、正文、表格区域

仅靠extract_words()还不够。我们需要主动识别“哪里是标题”“哪里是表格”。以下函数通过分析字体大小、加粗、居中程度和上下文空白，自动标注文本块类型：

import numpy as np from collections import defaultdict def classify_text_blocks(words: list) -> list: """ 对words列表中的每个文本块分类：'title', 'subtitle', 'table_header', 'body', 'footer' 依据：字体大小、是否加粗、是否居中、与上下块的垂直间距 """ if not words: return [] # 统计字体大小分布，取众数作为正文基准字号 sizes = [w.get('height', 0) for w in words] base_size = float(np.median([s for s in sizes if s > 0])) # 计算每行的水平中心（用于判断居中） page_width = max(w['x1'] for w in words) if words else 595 # A4宽约595pt classified = [] for i, w in enumerate(words): text = w['text'].strip() if not text: continue size = w.get('height', 0) is_bold = 'Bold' in w.get('fontname', '') or 'bold' in w.get('fontname', '').lower() x_center = (w['x0'] + w['x1']) / 2 center_ratio = abs(x_center - page_width/2) / (page_width/2) # 居中程度：0=完全居中，1=靠边 # 垂直间距：与上一块的距离（若存在） v_gap_prev = 0 if i > 0: prev_top = words[i-1]['top'] v_gap_prev = w['top'] - prev_top - words[i-1].get('height', 0) # 分类规则（可调！这是业务适配的关键） if size > base_size * 1.6 and is_bold and center_ratio < 0.2: label = 'title' elif size > base_size * 1.3 and is_bold and v_gap_prev > base_size * 1.5: label = 'subtitle' elif size > base_size * 1.1 and '表' in text and ('序号' in text or '名称' in text): label = 'table_header' elif center_ratio < 0.1 and '第' in text and '章' in text: label = 'title' elif v_gap_prev > base_size * 3: # 大空白上方，大概率是新段落开头 label = 'body' else: label = 'body' classified.append({ 'text': text, 'label': label, 'x0': w['x0'], 'top': w['top'], 'size_ratio': size / base_size, 'v_gap_prev': v_gap_prev }) return classified # 使用示例 words = layout["words"] classified_blocks = classify_text_blocks(words) for b in classified_blocks[:8]: print(f"[{b['label']:<12}] '{b['text']}' (size×{b['size_ratio']:.1f}, gap={b['v_gap_prev']:.1f})")

参数说明与调优提示：

• base_size * 1.6：标题字号阈值，实际项目中需根据PDF样本调整（技术文档常为16pt，合同可能为14pt）；
• center_ratio < 0.2：居中容忍度，0.2表示水平偏移不超过页面宽度10%，对扫描件偏斜鲁棒；
• v_gap_prev > base_size * 3：段前空行阈值，base_size是动态基准，避免硬编码20这种魔法数字；
• 血泪经验：规则必须可配置！我们最终将这些阈值写入config.yaml，不同文档类型（标书/论文/合同）加载不同配置，而非写死在代码里。

2.3 表格提取：绕过extract_table()的玄学失败，用rects+words重建网格

pdfplumber.Page.extract_table()经常失败——尤其当表格无边框、或只有横向线时。更可靠的做法是：用rects找表格边界框 → 用words落入该框内的文本 → 按坐标聚类行列。以下是核心实现：

def extract_tables_from_rects(words: list, rects: list, tolerance: float = 5.0) -> list: """ 用rects识别表格区域，再用words填充单元格 tolerance: 坐标聚类容差（pt） """ tables = [] # 步骤1：从rects中筛选出可能是表格外框的矩形（面积大、长宽比合理） table_bboxes = [] for r in rects: if 'width' in r and 'height' in r: area = r['width'] * r['height'] aspect = max(r['width'], r['height']) / min(r['width'], r['height'] + 1e-6) # 过滤掉太小或太细长的矩形（如页眉线） if area > 1000 and aspect < 10: table_bboxes.append((r['x0'], r['top'], r['x1'], r['bottom'])) # 步骤2：对每个候选bbox，提取其中的words for bbox in table_bboxes: x0, top, x1, bottom = bbox table_words = [ w for w in words if w['x0'] >= x0-2 and w['x1'] <= x1+2 and w['top'] >= top-2 and w['top'] <= bottom+2 ] if len(table_words) < 4: # 至少4个词才像表格 continue # 步骤3：按y坐标聚类行（K-means太重，用简单阈值法） rows = defaultdict(list) y_coords = sorted(set(int(w['top']) for w in table_words)) # 合并相近y值（tolerance内视为同一行） current_row_y = None for w in table_words: y_round = int(w['top']) if current_row_y is None or abs(y_round - current_row_y) > tolerance: current_row_y = y_round rows[current_row_y].append(w) # 步骤4：对每行，按x坐标聚类列 table_data = [] for row_y in sorted(rows.keys()): row_words = rows[row_y] if not row_words: continue # 按x0排序，用gap检测列分隔 row_words.sort(key=lambda w: w['x0']) cols = [] last_x1 = row_words[0]['x0'] - 10 for w in row_words: if w['x0'] - last_x1 > tolerance * 2: # 列间空隙大于2倍容差 cols.append([]) cols[-1].append(w['text']) last_x1 = w['x1'] table_data.append([''.join(c) for c in cols]) if table_data: tables.append(table_data) return tables # 调用示例 tables = extract_tables_from_rects(layout["words"], layout["rects"]) print(f"检测到 {len(tables)} 个表格") if tables: print("第一个表格前2行：") for i, row in enumerate(tables[0][:2]): print(f" Row{i}: {row}")

为什么这比extract_table()稳？

• extract_table()依赖PDF内部的“表格对象”元数据，而多数PDF生成器（尤其是Word导出）根本不写这个；
• 我们用rects找物理边框，words找内容，完全脱离PDF元数据，对扫描件、网页转PDF同样有效；
• tolerance参数控制聚类松紧，扫描件模糊时调大（8~10），高清PDF调小（3~5），这是唯一需要人工调的参数。

3. 领域适配的信息抽取：规则引擎打底，轻量模型兜底

有了结构化文本块，下一步是抽取“谁做了什么，在何时何地，用什么工具”。通用NER模型（如spaCy的zh_core_web_sm）在PDF文档上效果惨淡：它没见过“甲方：XX科技有限公司”这种格式，也分不清“2023年12月31日前”是截止日期还是成立时间。我们的策略是：80%靠规则（精准、可控、零训练），20%靠微调小模型（处理规则覆盖不到的长尾）。规则部分必须支持“上下文感知”——比如“项目周期：”后面的数字串才是工期，而非全文所有数字。

3.1 基于正则与上下文的规则抽取引擎

我们设计一个RuleBasedExtractor类，支持三种规则类型：KEYWORD_FOLLOWED（关键词后跟随）、KEYWORD_SURROUNDED（关键词包围）、PATTERN_ONLY（纯正则）。所有规则可配置、可关闭、可优先级排序：

import re from typing import List, Dict, Any, Optional class RuleBasedExtractor: def __init__(self): self.rules = [] def add_rule(self, name: str, pattern: str, rule_type: str = "KEYWORD_FOLLOWED", context_window: int = 3, priority: int = 10): """ 添加抽取规则 rule_type: KEYWORD_FOLLOWED, KEYWORD_SURROUNDED, PATTERN_ONLY context_window: 关键词前后扫描的文本块数量（仅KEYWORD_*有效） """ self.rules.append({ "name": name, "pattern": pattern, "type": rule_type, "context_window": context_window, "priority": priority }) def extract(self, classified_blocks: List[Dict]) -> Dict[str, List[str]]: results = defaultdict(list) # 按priority排序规则，高优先级先执行 sorted_rules = sorted(self.rules, key=lambda x: x['priority'], reverse=True) for rule in sorted_rules: if rule['type'] == "KEYWORD_FOLLOWED": # 找到匹配pattern的块，取其后context_window个块的text for i, block in enumerate(classified_blocks): if re.search(rule['pattern'], block['text']): # 向后取最多context_window个非空块 for j in range(i+1, min(i+1+rule['context_window'], len(classified_blocks))): next_block = classified_blocks[j] if next_block['text'].strip() and len(next_block['text'].strip()) > 2: # 清洗：去括号、去单位、标准化空格 clean_text = re.sub(r'[（）\(\)\[\]\{\}]+', '', next_block['text']) clean_text = re.sub(r'\s+', ' ', clean_text).strip() if clean_text: results[rule['name']].append(clean_text) break # 只取第一个后续块，避免误采 elif rule['type'] == "KEYWORD_SURROUNDED": # 匹配pattern，取其前后各context_window块，拼接成上下文 for i, block in enumerate(classified_blocks): if re.search(rule['pattern'], block['text']): context_blocks = [] for j in range(max(0, i-rule['context_window']), min(len(classified_blocks), i+rule['context_window']+1)): if j != i: # 排除关键词自身 context_blocks.append(classified_blocks[j]['text']) full_context = ' '.join(context_blocks) # 在上下文中用pattern抽取（如日期、金额） matches = re.findall(rule['pattern'], full_context) for m in matches: if isinstance(m, tuple): results[rule['name']].extend([x for x in m if x.strip()]) else: results[rule['name']].append(m) elif rule['type'] == "PATTERN_ONLY": for block in classified_blocks: matches = re.findall(rule['pattern'], block['text']) for m in matches: if isinstance(m, tuple): results[rule['name']].extend([x for x in m if x.strip()]) else: results[rule['name']].append(m) return dict(results) # 初始化抽取器并添加规则 extractor = RuleBasedExtractor() # 规则1：项目周期（关键词后跟随） extractor.add_rule( name="project_duration", pattern=r"(项目周期|工期|建设周期|实施周期)", rule_type="KEYWORD_FOLLOWED", context_window=2, priority=100 ) # 规则2：合同金额（关键词包围，取金额数字） extractor.add_rule( name="contract_amount", pattern=r"([0-9,.\u4e00-\u9fa5]{2,15}元|[0-9,.\u4e00-\u9fa5]{2,15}万元)", rule_type="KEYWORD_SURROUNDED", context_window=3, priority=90 ) # 规则3：日期（纯正则，全局扫描） extractor.add_rule( name="date", pattern=r"(\d{4}年\d{1,2}月\d{1,2}日|\d{4}-\d{1,2}-\d{1,2}|\d{4}/\d{1,2}/\d{1,2})", rule_type="PATTERN_ONLY", priority=80 ) # 执行抽取 extraction_result = extractor.extract(classified_blocks) print("抽取结果：") for k, v in extraction_result.items(): print(f" {k}: {v}")

关键设计点：

• priority机制确保“项目周期”规则（高精度）优先于“日期”规则（易误召），避免日期被错误归为工期；
• KEYWORD_FOLLOWED只取第一个后续块，防止“项目周期：3个月，付款方式：...”中把“付款方式”也抽进来；
• KEYWORD_SURROUNDED用上下文增强正则，解决“人民币叁佰万元整”这类中文大写金额识别；
• 所有规则存于rules.yaml，可热加载，无需改代码。

3.2 轻量微调模型兜底：用DistilBERT微调一个10MB的领域NER模型

规则覆盖不了所有情况，比如“甲方指定第三方检测机构进行验收”，这里“第三方检测机构”是组织名，但规则很难穷举。此时用一个轻量模型兜底。我们选用distilbert-base-chinese（110M参数，推理快），在自建的小规模PDF领域NER数据集（500句，标注了ORG/DATE/AMOUNT/TERM四类）上微调，最终模型仅10MB，CPU上单句推理<200ms。

# train_ner.py（简化版） from transformers import DistilBertTokenizer, DistilBertForTokenClassification, TrainingArguments, Trainer from datasets import Dataset import torch # 1. 加载数据（格式：[{"tokens": ["甲","方","指","定",...], "ner_tags": [0,0,1,1,...]}]） train_data = load_our_pdf_ner_dataset("data/train.json") # 2. Tokenizer & Model tokenizer = DistilBertTokenizer.from_pretrained("distilbert-base-chinese") model = DistilBertForTokenClassification.from_pretrained( "distilbert-base-chinese", num_labels=5, # O, ORG, DATE, AMOUNT, TERM id2label={0: "O", 1: "ORG", 2: "DATE", 3: "AMOUNT", 4: "TERM"}, label2id={"O": 0, "ORG": 1, "DATE": 2, "AMOUNT": 3, "TERM": 4} ) # 3. 数据预处理 def tokenize_and_align_labels(examples): tokenized_inputs = tokenizer( examples["tokens"], truncation=True, is_split_into_words=True, padding=True ) labels = [] for i, label in enumerate(examples["ner_tags"]): word_ids = tokenized_inputs.word_ids(batch_index=i) previous_word_idx = None label_ids = [] for word_idx in word_ids: if word_idx is None: label_ids.append(-100) # CLS/SEP/PAD elif word_idx != previous_word_idx: label_ids.append(label[word_idx]) else: label_ids.append(-100) # 子词继承首词标签 previous_word_idx = word_idx labels.append(label_ids) tokenized_inputs["labels"] = labels return tokenized_inputs # 4. 训练 training_args = TrainingArguments( output_dir="./ner_model", num_train_epochs=3, per_device_train_batch_size=16, save_steps=500, logging_steps=100, evaluation_strategy="steps", load_best_model_at_end=True, ) trainer = Trainer( model=model, args=training_args, train_dataset=Dataset.from_list(train_data).map(tokenize_and_align_labels, batched=True), ) trainer.train() trainer.save_model("./ner_model_final")

部署时的精简技巧：

• 用torch.quantization量化模型，体积再减30%，速度提升2倍；
• 推理时禁用gradient_checkpointing，用model.eval()+torch.no_grad()；
• 只对规则抽取为空的文本块调用模型，避免无谓开销。

3.3 实体消歧与关系抽取：用规则模板连接抽取结果

抽取到一堆“甲方”“乙方”“工期3个月”“验收标准”后，如何知道“工期3个月”属于哪个项目？“验收标准”对应哪份合同？这就是实体消歧与关系抽取。我们不用复杂图神经网络，而用基于文档结构的位置约束+规则模板：

def build_relations(extracted: dict, classified_blocks: list) -> list: """ 基于位置关系构建 (subject, predicate, object) 三元组 假设：同一章节下的抽取结果属于同一主题 """ relations = [] # 步骤1：按标题块分组文本块（找到每个标题下的所有子块） sections = [] current_section = {"title": "", "blocks": []} for block in classified_blocks: if block['label'] in ['title', 'subtitle']: if current_section["title"]: sections.append(current_section) current_section = {"title": block['text'], "blocks": []} else: current_section["blocks"].append(block) if current_section["title"]: sections.append(current_section) # 步骤2：对每个section，将抽取结果绑定到该section title for sec in sections: if not sec["title"] or not sec["blocks"]: continue # 绑定工期到章节 if "project_duration" in extracted and extracted["project_duration"]: for dur in extracted["project_duration"][:1]: # 取第一个 relations.append(( sec["title"].strip(), "has_duration", dur.strip() )) # 绑定金额到章节（若金额出现在该章节内） if "contract_amount" in extracted and extracted["contract_amount"]: # 检查金额是否在当前章节的blocks中出现 for amt in extracted["contract_amount"]: for b in sec["blocks"]: if amt in b['text'] or b['text'] in amt or abs(len(amt)-len(b['text'])) < 5: relations.append(( sec["title"].strip(), "has_amount", amt.strip() )) break return relations # 构建关系 relations = build_relations(extraction_result, classified_blocks) print("构建的关系三元组：") for r in relations[:5]: print(f" ({r[0]}, {r[1]}, {r[2]})")

为什么不用LLM做关系抽取？

• LLM在长文档上成本高、延迟大、不可控；
• PDF文档关系高度结构化（“第X章”下所有内容属于该章），位置约束比语义推理更准；
• 这是“用业务逻辑降维打击技术复杂度”的典型场景。

4. 知识图谱构建与存储：Neo4j轻量部署与Schema设计

抽取的三元组只是中间产物，必须存入图数据库才能支持后续的图遍历与语义检索。我们选择Neo4j（社区版免费，Docker秒启），而非更重的JanusGraph或Nebula，因为：PDF知识图谱节点类型少（<10种）、关系简单（<5种）、查询以“找关联”为主，Neo4j的Cypher语法直观，运维成本最低。关键不在“用不用图数据库”，而在Schema设计是否贴合PDF文档特性——比如，不能把“甲方”“乙方”都建为Person节点，而应建为Party，并用role属性区分。

4.1 PDF知识图谱的最小可行Schema设计

传统知识图谱Schema（如DBpedia）过于通用，导致PDF中大量信息无法映射。我们定义一套面向文档解析的极简Schema：

Schema设计原则：

• 拒绝过度泛化：不建Person/Organization节点，统一用Entity+type属性，避免节点爆炸；
• 保留溯源信息：每个Entity存source_text（原文片段）和confidence（规则置信度或模型概率），便于人工校验；
• 关系命名动词化：BELONGS_TO比in_section更符合Cypher习惯，且语义清晰。

4.2 用Neo4j Python Driver批量导入三元组

Neo4j官方驱动neo4j包支持事务批量写入，比HTTP API快10倍。以下代码将relations列表（如("第一章", "has_duration", "3个月")）转化为Cypher并高效导入：

from neo4j import GraphDatabase import logging class Neo4jImporter: def __init__(self, uri: str, user: str, password: str): self.driver = GraphDatabase.driver(uri, auth=(user, password)) def import_relations(self, relations: list, doc_name: str): """ 导入关系三元组，自动创建Document、Section、Entity节点 relations: [("SectionTitle", "predicate", "object_value"), ...] """ def _tx_func(tx, rels, doc_name): # 创建Document节点（如果不存在） tx.run( "MERGE (d:Document {name: $doc_name}) " "ON CREATE SET d.parsed_at = timestamp(), d.source_path = $doc_name", doc_name=doc_name ) # 批量创建Section和Entity，并建立关系 for subj, pred, obj in rels: # 创建Section节点（如果不存在） tx.run( "MERGE (s:Section {title: $title}) " "ON CREATE SET s.level = 1, s.page_range = '1-5'", title=subj ) # 创建Entity节点（如果不存在） tx.run( "MERGE (e:Entity {name: $name}) " "ON CREATE SET e.type = $type, e.source_text = $source_text, e.confidence = $conf", name=obj, type=self._infer_entity_type(obj), source_text=obj, conf=0.95 # 规则抽取置信度设为0.95 ) # 建立关系 cypher = f""" MATCH (s:Section {{title: $subj}}) MATCH (e:Entity {{name: $obj}}) MERGE (s)-[r:{pred.upper()}]->(e) """ tx.run(cypher, subj=subj, obj=obj) with self.driver.session() as session: session.write_transaction(_tx_func, relations, doc_name) def _infer_entity_type(self, text: str) -> str: """简单类型推断，可替换为更准的规则或小模型""" if re.search(r"\d{4}年\d{1,2}月\d{1,2}日|\d{4}-\d{1,2}-\d{1,2}", text): return "DATE" elif re.search(r"[0-9,.\u4e00-\u9fa5]+(元|万元|亿美元)", text): return "AMOUNT" elif re.search(r"(甲方|乙方|丙方|供应商|采购方|委托方)", text): return "PARTY" else: return "TERM" # 使用示例 importer = Neo4jImporter("bolt://localhost:7687", "neo4j", "password") importer.import_relations(relations, "招标文件_V2.3.pdf") print("图谱导入完成")

性能优化点：

• MERGE替代CREATE避免重复节点；
• ON CREATE SET只在新建时赋值，避免覆盖已有属性；
• 所有操作在单个事务中完成，减少网络往返；
• 生产环境务必加索引：CREATE INDEX ON :Section(title); CREATE INDEX ON :Entity(name);

4.3 避坑：PDF解析与图谱构建的5个高频翻车现场

现象1：表格提取后，同一行的单元格内容被拆到不同行，导致“甲方：A公司”变成两行
原因：extract_tables_from_rects()中tolerance设得太小（如2），扫描件轻微扭曲导致y坐标分散。
解决：对扫描PDF，tolerance设为8~10；或先用OpenCV做简单透视校正（见附录脚本）。

现象2：规则抽取“项目周期”时，把“项目周期：3个月”和“维护周期：12个月”全抽出来，无法区分
原因：规则未限定上下文范围，KEYWORD_FOLLOWED取了所有后续块。
解决：在add_rule()中增加max_length=20参数，限制匹配文本长度；或增加二级规则：“若前一块含‘维护’，则跳过”。

现象3：Neo4j导入时报错Neo4jError: Node with label 'Section' must have the property 'title'
原因：MERGE (s:Section {title: $title})中$title为空字符串，导致创建无title的Section节点。
解决：在import_relations()前过滤空title：rels = [(s,p,o) for s,p,o in relations if s.strip() and o.strip()]。

现象4：中文在Neo4j Browser中显示为乱码（）
原因：Neo4j服务器启动时未指定UTF-8编码，或Docker运行时未挂载locale。
解决：Docker启动加参数-e NEO4J_dbms_default__database_encoding=UTF-8；或在neo4j.conf中加dbms.default_database_encoding=UTF-8。

现象5：知识图谱查询很慢，MATCH (s:Section)-[r]->(e:Entity) WHERE e.name CONTAINS '甲方'耗时>5s
原因：未建索引，全表扫描。
解决：执行CREATE INDEX entity_name_index ON :Entity(name);，首次建索引需几分钟，之后查询<100ms。

5. 基于知识图谱的信息检索：从关键词搜索到语义导航

图谱建好了，但用户不会写Cypher。我们需要提供自然语言接口：输入“甲方是谁？”，返回所有`

本文还有配套的精品资源，点击获取