|
|
# -*- coding: utf-8 -*-
|
|
|
"""
|
|
|
数学题目分析系统 v5.0（离线可用版）
|
|
|
功能特性：
|
|
|
1. 本地规则引擎为主 + 大模型增强（可选）
|
|
|
2. 自动Neo4j数据清洗
|
|
|
3. 完善的错误处理
|
|
|
4. 详细的运行日志
|
|
|
"""
|
|
|
from Config import *
|
|
|
|
|
|
import hashlib
|
|
|
import json
|
|
|
import re
|
|
|
from typing import Dict, List
|
|
|
|
|
|
import jieba
|
|
|
import requests
|
|
|
from py2neo import Graph
|
|
|
from Config import *
|
|
|
|
|
|
# 初始化分词器
|
|
|
jieba.initialize()
|
|
|
|
|
|
|
|
|
# ================== 配置区 ==================
|
|
|
class Config:
|
|
|
# 大模型配置（默认关闭）
|
|
|
LLM_ENABLED = True # 设置为True启用大模型
|
|
|
LLM_TIMEOUT = 8
|
|
|
LLM_MAX_RETRIES = 2
|
|
|
|
|
|
# 系统参数
|
|
|
MAX_CONTENT_LENGTH = 500
|
|
|
|
|
|
|
|
|
# ================== 本地知识库 ==================
|
|
|
class LocalKnowledgeBase:
|
|
|
"""本地规则分析引擎"""
|
|
|
RULES = {
|
|
|
'arithmetic': {
|
|
|
'keywords': ['买', '卖', '元', '还剩', '单价', '总价'],
|
|
|
'knowledge': ['四则运算应用（购物问题）'],
|
|
|
'literacy': ['数感培养']
|
|
|
},
|
|
|
'travel': {
|
|
|
'keywords': ['相遇', '速度', '距离', '时间', '出发'],
|
|
|
'knowledge': ['相遇问题解决方案'],
|
|
|
'literacy': ['空间观念']
|
|
|
},
|
|
|
'work': {
|
|
|
'keywords': ['合作', '效率', '工期', '完成', '单独'],
|
|
|
'knowledge': ['工程合作效率计算'],
|
|
|
'literacy': ['模型思想']
|
|
|
},
|
|
|
'geometry': {
|
|
|
'keywords': ['面积', '周长', '体积', '平方', '立方'],
|
|
|
'knowledge': ['几何图形面积计算'],
|
|
|
'literacy': ['空间观念']
|
|
|
},
|
|
|
'ratio': {
|
|
|
'keywords': ['百分比', '浓度', '稀释', '配比'],
|
|
|
'knowledge': ['浓度问题配比计算'],
|
|
|
'literacy': ['数据分析']
|
|
|
}
|
|
|
}
|
|
|
|
|
|
@classmethod
|
|
|
def analyze(cls, content: str) -> dict:
|
|
|
"""本地规则分析"""
|
|
|
result = {
|
|
|
'problem_types': [],
|
|
|
'knowledge_points': [],
|
|
|
'literacy_points': []
|
|
|
}
|
|
|
|
|
|
words = set(jieba.cut(content))
|
|
|
for ptype, config in cls.RULES.items():
|
|
|
if len(words & set(config['keywords'])) >= 2:
|
|
|
result['problem_types'].append(ptype)
|
|
|
result['knowledge_points'].extend(config['knowledge'])
|
|
|
result['literacy_points'].extend(config['literacy'])
|
|
|
return result
|
|
|
|
|
|
|
|
|
# ================== 大模型客户端 ==================
|
|
|
class LLMClient:
|
|
|
"""增强版大模型客户端"""
|
|
|
|
|
|
def __init__(self):
|
|
|
self.enabled = Config.LLM_ENABLED
|
|
|
self.base_url = MODEL_API_URL
|
|
|
self.headers = {"Authorization": f"Bearer {MODEL_API_KEY}"}
|
|
|
|
|
|
def analyze_problem(self, content: str) -> dict:
|
|
|
"""带重试机制的分析请求"""
|
|
|
if not self.enabled:
|
|
|
return {}
|
|
|
|
|
|
for attempt in range(Config.LLM_MAX_RETRIES):
|
|
|
try:
|
|
|
response = requests.post(
|
|
|
f"{self.base_url}/chat/completions",
|
|
|
headers=self.headers,
|
|
|
json={
|
|
|
"model": MODEL_NAME,
|
|
|
"messages": [{
|
|
|
"role": "user",
|
|
|
"content": f"分析数学题目：{content}"
|
|
|
}],
|
|
|
"temperature": 0.3
|
|
|
},
|
|
|
timeout=Config.LLM_TIMEOUT
|
|
|
)
|
|
|
response.raise_for_status()
|
|
|
return self._parse_response(response.json())
|
|
|
except requests.exceptions.RequestException as e:
|
|
|
print(f"🌐 网络错误（尝试 {attempt + 1}/{Config.LLM_MAX_RETRIES}）: {str(e)}")
|
|
|
return {}
|
|
|
|
|
|
def _parse_response(self, response: dict) -> dict:
|
|
|
"""解析大模型响应"""
|
|
|
try:
|
|
|
content = response['choices'][0]['message']['content']
|
|
|
return json.loads(re.search(r'\{.*\}', content, re.DOTALL).group())
|
|
|
except Exception as e:
|
|
|
print(f"🔴 解析失败: {str(e)}")
|
|
|
return {}
|
|
|
|
|
|
|
|
|
# ================== 知识图谱管理 ==================
|
|
|
class KnowledgeManager:
|
|
|
"""增强版知识图谱管理器"""
|
|
|
|
|
|
def __init__(self):
|
|
|
self.graph = Graph(NEO4J_URI, auth=NEO4J_AUTH)
|
|
|
self._clean_data()
|
|
|
self.knowledge_map = self._load_knowledge()
|
|
|
self.literacy_map = self._load_literacy()
|
|
|
|
|
|
def _clean_data(self):
|
|
|
"""自动数据清洗"""
|
|
|
self.graph.run("""
|
|
|
MATCH (n)
|
|
|
WHERE n.name CONTAINS '测试' OR n.id IS NULL
|
|
|
DETACH DELETE n
|
|
|
""")
|
|
|
|
|
|
def _load_knowledge(self) -> Dict[str, str]:
|
|
|
"""加载知识点"""
|
|
|
return {rec['n.id']: rec['n.name']
|
|
|
for rec in self.graph.run("MATCH (n:KnowledgePoint) RETURN n.id, n.name")}
|
|
|
|
|
|
def _load_literacy(self) -> Dict[str, str]:
|
|
|
"""加载素养点"""
|
|
|
return {rec['n.value']: rec['n.title']
|
|
|
for rec in self.graph.run("MATCH (n:LiteracyNode) RETURN n.value, n.title")}
|
|
|
|
|
|
def store_analysis(self, question_id: str, content: str,
|
|
|
knowledge: List[str], literacy: List[str]):
|
|
|
"""事务化存储方法"""
|
|
|
tx = self.graph.begin()
|
|
|
try:
|
|
|
# 转义特殊字符
|
|
|
safe_content = content.replace("'", "\\'")
|
|
|
|
|
|
# 创建/更新题目节点
|
|
|
tx.run(f"""
|
|
|
MERGE (q:Question {{id: '{question_id}'}})
|
|
|
SET q.content = '{safe_content}'
|
|
|
""")
|
|
|
|
|
|
# 关联知识点
|
|
|
for kp_name in knowledge:
|
|
|
if kp_id := next((k for k, v in self.knowledge_map.items() if v == kp_name), None):
|
|
|
tx.run(f"""
|
|
|
MERGE (kp:KnowledgePoint {{id: '{kp_id}'}})
|
|
|
WITH kp
|
|
|
MATCH (q:Question {{id: '{question_id}'}})
|
|
|
MERGE (q)-[:REQUIRES_KNOWLEDGE]->(kp)
|
|
|
""")
|
|
|
|
|
|
# 关联素养点
|
|
|
for lit_name in literacy:
|
|
|
if lit_id := next((k for k, v in self.literacy_map.items() if v == lit_name), None):
|
|
|
tx.run(f"""
|
|
|
MERGE (lp:LiteracyNode {{value: '{lit_id}'}})
|
|
|
WITH lp
|
|
|
MATCH (q:Question {{id: '{question_id}'}})
|
|
|
MERGE (q)-[:DEVELOPS_LITERACY]->(lp)
|
|
|
""")
|
|
|
|
|
|
self.graph.commit(tx)
|
|
|
print("✅ 数据存储成功")
|
|
|
except Exception as e:
|
|
|
self.graph.rollback(tx)
|
|
|
print(f"❌ 存储失败: {str(e)}")
|
|
|
|
|
|
|
|
|
# ================== 核心分析引擎 ==================
|
|
|
class ProblemAnalyzer:
|
|
|
"""题目分析处理器"""
|
|
|
|
|
|
def __init__(self, content: str):
|
|
|
self.original = content
|
|
|
self.content = self._preprocess(content)
|
|
|
self.question_id = hashlib.sha256(content.encode()).hexdigest()[:12]
|
|
|
self.kg = KnowledgeManager()
|
|
|
self.llm = LLMClient()
|
|
|
|
|
|
def _preprocess(self, text: str) -> str:
|
|
|
"""文本预处理"""
|
|
|
return re.sub(r'[^\w\u4e00-\u9fa5]', '', text)[:Config.MAX_CONTENT_LENGTH]
|
|
|
|
|
|
def analyze(self) -> dict:
|
|
|
"""执行分析流程"""
|
|
|
# 本地规则分析
|
|
|
local_result = LocalKnowledgeBase.analyze(self.content)
|
|
|
|
|
|
# 大模型分析
|
|
|
llm_result = self.llm.analyze_problem(self.original)
|
|
|
|
|
|
# 结果融合
|
|
|
return {
|
|
|
"problem_id": self.question_id,
|
|
|
"problem_types": list(set(
|
|
|
local_result.get('problem_types', []) +
|
|
|
llm_result.get('problem_types', [])
|
|
|
))[:3],
|
|
|
"knowledge_points": list(set(
|
|
|
local_result.get('knowledge_points', []) +
|
|
|
llm_result.get('knowledge_points', [])
|
|
|
))[:2],
|
|
|
"literacy_points": list(set(
|
|
|
local_result.get('literacy_points', []) +
|
|
|
llm_result.get('literacy_points', [])
|
|
|
))[:2]
|
|
|
}
|
|
|
|
|
|
def execute(self):
|
|
|
"""执行完整流程"""
|
|
|
print(f"\n🔍 开始分析题目：{self.original[:50]}...")
|
|
|
|
|
|
analysis = self.analyze()
|
|
|
|
|
|
print("\n📊 分析报告：")
|
|
|
print(f" 题型识别：{analysis.get('problem_types', [])}")
|
|
|
print(f" 推荐知识点：{analysis.get('knowledge_points', [])}")
|
|
|
print(f" 关联素养点：{analysis.get('literacy_points', [])}")
|
|
|
|
|
|
# 存储到知识图谱
|
|
|
self.kg.store_analysis(
|
|
|
question_id=analysis['problem_id'],
|
|
|
content=self.content,
|
|
|
knowledge=analysis.get('knowledge_points', []),
|
|
|
literacy=analysis.get('literacy_points', [])
|
|
|
)
|
|
|
|
|
|
|
|
|
# ================== 测试用例 ==================
|
|
|
if __name__ == '__main__':
|
|
|
test_cases = [
|
|
|
"小明用50元买了3本笔记本，每本8元，还剩多少钱？",
|
|
|
"甲乙两车相距300公里，甲车速度60km/h，乙车40km/h，几小时后相遇？",
|
|
|
"一项工程甲队单独做需要10天，乙队需要15天，两队合作需要多少天？",
|
|
|
"一个长方形长8cm，宽5cm，求面积和周长",
|
|
|
"含盐20%的盐水500克，要配成15%的盐水，需加水多少克？"
|
|
|
]
|
|
|
|
|
|
for question in test_cases:
|
|
|
print("\n" + "=" * 80)
|
|
|
print(f"📚 处理题目：{question}")
|
|
|
analyzer = ProblemAnalyzer(question)
|
|
|
analyzer.execute() |
