|
|
# -*- coding: utf-8 -*-
|
|
|
"""
|
|
|
数学题目分析系统 v6.3（稳定流式处理版）
|
|
|
"""
|
|
|
|
|
|
import re
|
|
|
import json
|
|
|
import hashlib
|
|
|
import requests
|
|
|
from py2neo import Graph
|
|
|
from typing import Dict, List
|
|
|
from Config import NEO4J_URI, NEO4J_AUTH, MODEL_API_URL, MODEL_API_KEY, MODEL_NAME
|
|
|
|
|
|
|
|
|
# ================== 配置类 ==================
|
|
|
class Config:
|
|
|
NEO4J_URI = NEO4J_URI
|
|
|
NEO4J_AUTH = NEO4J_AUTH
|
|
|
MODEL_API_URL = MODEL_API_URL
|
|
|
MODEL_API_KEY = MODEL_API_KEY
|
|
|
MODEL_NAME = MODEL_NAME
|
|
|
MAX_CONTENT_LENGTH = 500
|
|
|
STREAM_TIMEOUT = 30
|
|
|
|
|
|
|
|
|
# ================== 知识图谱管理 ==================
|
|
|
class KnowledgeManager:
|
|
|
def __init__(self):
|
|
|
self.graph = Graph(Config.NEO4J_URI, auth=Config.NEO4J_AUTH)
|
|
|
self._verify_connection()
|
|
|
self.knowledge_map = self._load_knowledge()
|
|
|
self.literacy_map = self._load_literacy()
|
|
|
print("✅ 知识库加载完成")
|
|
|
print(f"有效知识点({len(self.knowledge_map)}个): {list(self.knowledge_map.keys())[:3]}...")
|
|
|
print(f"有效素养点({len(self.literacy_map)}个): {list(self.literacy_map.keys())[:3]}...")
|
|
|
|
|
|
def _verify_connection(self):
|
|
|
"""安全连接验证"""
|
|
|
try:
|
|
|
self.graph.run("RETURN 1 AS test")
|
|
|
print("✅ Neo4j连接验证成功")
|
|
|
except Exception as e:
|
|
|
print(f"❌ Neo4j连接失败: {str(e)}")
|
|
|
raise
|
|
|
|
|
|
def _load_knowledge(self) -> Dict[str, str]:
|
|
|
"""安全加载知识点"""
|
|
|
records = self.graph.run("MATCH (n:KnowledgePoint) WHERE n.name IS NOT NULL RETURN n.id, n.name").data()
|
|
|
return {rec['n.name'].strip(): rec['n.id'] for rec in records if rec['n.name'] and rec['n.name'].strip()}
|
|
|
|
|
|
def _load_literacy(self) -> Dict[str, str]:
|
|
|
"""安全加载素养点"""
|
|
|
records = self.graph.run("MATCH (n:LiteracyNode) WHERE n.title IS NOT NULL RETURN n.value, n.title").data()
|
|
|
return {rec['n.title'].strip(): rec['n.value'] for rec in records if rec['n.title'] and rec['n.title'].strip()}
|
|
|
|
|
|
def store_analysis(self, question_id: str, content: str,
|
|
|
knowledge: List[str], literacy: List[str]):
|
|
|
"""增强存储方法"""
|
|
|
tx = self.graph.begin()
|
|
|
try:
|
|
|
# 创建/更新题目节点
|
|
|
tx.run("""
|
|
|
MERGE (q:Question {id: $id})
|
|
|
SET q.content = $content, q.updateTime = timestamp()
|
|
|
""", {"id": question_id, "content": content})
|
|
|
|
|
|
# 关联知识点
|
|
|
valid_kp = []
|
|
|
for name in knowledge:
|
|
|
clean_name = name.strip()
|
|
|
if kp_id := self.knowledge_map.get(clean_name):
|
|
|
tx.run("""
|
|
|
MATCH (q:Question {id: $qid}), (kp:KnowledgePoint {id: $kpid})
|
|
|
MERGE (q)-[r:REQUIRES_KNOWLEDGE]->(kp)
|
|
|
SET r.lastUsed = timestamp()
|
|
|
""", {"qid": question_id, "kpid": kp_id})
|
|
|
valid_kp.append(clean_name)
|
|
|
|
|
|
# 关联素养点
|
|
|
valid_lp = []
|
|
|
for title in literacy:
|
|
|
clean_title = title.strip()
|
|
|
if lit_id := self.literacy_map.get(clean_title):
|
|
|
tx.run("""
|
|
|
MATCH (q:Question {id: $qid}), (lp:LiteracyNode {value: $lpid})
|
|
|
MERGE (q)-[r:DEVELOPS_LITERACY]->(lp)
|
|
|
SET r.lastUsed = timestamp()
|
|
|
""", {"qid": question_id, "lpid": lit_id})
|
|
|
valid_lp.append(clean_title)
|
|
|
|
|
|
self.graph.commit(tx)
|
|
|
print(f"✅ 存储成功 - 知识点: {valid_kp}, 素养点: {valid_lp}")
|
|
|
except Exception as e:
|
|
|
self.graph.rollback(tx)
|
|
|
print(f"❌ 存储失败: {str(e)}")
|
|
|
|
|
|
|
|
|
# ================== 大模型客户端 ==================
|
|
|
class StreamLLMClient:
|
|
|
def __init__(self, kg: KnowledgeManager):
|
|
|
self.kg = kg
|
|
|
self.base_url = Config.MODEL_API_URL
|
|
|
self.headers = {
|
|
|
"Authorization": f"Bearer {Config.MODEL_API_KEY}",
|
|
|
"Content-Type": "application/json",
|
|
|
"Accept": "application/json"
|
|
|
}
|
|
|
|
|
|
def analyze_problem(self, content: str) -> dict:
|
|
|
"""增强的流式分析"""
|
|
|
try:
|
|
|
prompt = self._build_prompt(content)
|
|
|
response = self._send_request(prompt)
|
|
|
return self._process_stream(response)
|
|
|
except Exception as e:
|
|
|
print(f"🔴 分析失败: {str(e)}")
|
|
|
return {}
|
|
|
|
|
|
def _build_prompt(self, content: str) -> str:
|
|
|
"""构建精准提示词"""
|
|
|
return f"""请严格按以下要求分析数学题目：
|
|
|
1. 知识点必须完全匹配以下列表中的名称（不要新增或修改）：
|
|
|
{self.kg.knowledge_map.keys()}
|
|
|
|
|
|
2. 素养点必须完全匹配以下列表中的名称：
|
|
|
{self.kg.literacy_map.keys()}
|
|
|
|
|
|
3. 返回严格JSON格式：
|
|
|
{{
|
|
|
"problem_types": ["题型"],
|
|
|
"knowledge_points": ["匹配的知识点"],
|
|
|
"literacy_points": ["匹配的素养点"]
|
|
|
}}
|
|
|
|
|
|
题目内容：{content}"""
|
|
|
|
|
|
def _send_request(self, prompt: str):
|
|
|
"""发送API请求"""
|
|
|
return requests.post(
|
|
|
f"{self.base_url}/chat/completions",
|
|
|
headers=self.headers,
|
|
|
json={
|
|
|
"model": Config.MODEL_NAME,
|
|
|
"messages": [{"role": "user", "content": prompt}],
|
|
|
"temperature": 0.1,
|
|
|
"stream": True
|
|
|
},
|
|
|
timeout=Config.STREAM_TIMEOUT,
|
|
|
stream=True
|
|
|
)
|
|
|
|
|
|
def _process_stream(self, response) -> dict:
|
|
|
"""可靠的流式处理"""
|
|
|
full_content = ""
|
|
|
try:
|
|
|
for chunk in response.iter_lines():
|
|
|
if chunk:
|
|
|
decoded = chunk.decode('utf-8').strip()
|
|
|
if decoded.startswith('data:'):
|
|
|
json_str = decoded[5:].strip()
|
|
|
if json_str == "[DONE]":
|
|
|
break
|
|
|
try:
|
|
|
data = json.loads(json_str)
|
|
|
if content := data['choices'][0]['delta'].get('content'):
|
|
|
full_content += content
|
|
|
except:
|
|
|
continue
|
|
|
|
|
|
# 调试日志
|
|
|
print(f"原始响应内容：\n{full_content}")
|
|
|
|
|
|
# 提取有效JSON
|
|
|
json_str = re.search(r'\{[\s\S]*\}', full_content).group()
|
|
|
return json.loads(json_str)
|
|
|
except json.JSONDecodeError:
|
|
|
print(f"⚠️ JSON解析失败，原始内容：{full_content}")
|
|
|
return {}
|
|
|
except Exception as e:
|
|
|
print(f"流处理异常：{str(e)}")
|
|
|
return {}
|
|
|
|
|
|
|
|
|
# ================== 核心引擎 ==================
|
|
|
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 = StreamLLMClient(self.kg)
|
|
|
|
|
|
def _preprocess(self, text: str) -> str:
|
|
|
"""文本预处理"""
|
|
|
return re.sub(r'[^\w\u4e00-\u9fa5]', '', text)[:Config.MAX_CONTENT_LENGTH]
|
|
|
|
|
|
def execute(self):
|
|
|
"""执行分析流程"""
|
|
|
print(f"\n🔍 分析题目: {self.original[:50]}...")
|
|
|
|
|
|
analysis = self.llm.analyze_problem(self.original)
|
|
|
if not analysis:
|
|
|
print("⚠️ 大模型分析失败")
|
|
|
return
|
|
|
|
|
|
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=self.question_id,
|
|
|
content=self.content,
|
|
|
knowledge=analysis.get('knowledge_points', []),
|
|
|
literacy=analysis.get('literacy_points', [])
|
|
|
)
|
|
|
|
|
|
|
|
|
# ================== 查询接口 ==================
|
|
|
def query_question(question_id: str):
|
|
|
try:
|
|
|
graph = Graph(Config.NEO4J_URI, auth=Config.NEO4J_AUTH)
|
|
|
result = graph.run("""
|
|
|
MATCH (q:Question {id: $id})
|
|
|
OPTIONAL MATCH (q)-[:REQUIRES_KNOWLEDGE]->(kp)
|
|
|
OPTIONAL MATCH (q)-[:DEVELOPS_LITERACY]->(lp)
|
|
|
RETURN q.content AS content,
|
|
|
collect(kp.name) AS knowledge,
|
|
|
collect(lp.title) AS literacy
|
|
|
""", id=question_id).data()
|
|
|
|
|
|
if result:
|
|
|
data = result[0]
|
|
|
print(f"\n🔍 查询结果（ID: {question_id}）")
|
|
|
print(f"内容: {data['content']}")
|
|
|
print(f"知识点: {data['knowledge']}")
|
|
|
print(f"素养点: {data['literacy']}")
|
|
|
else:
|
|
|
print("未找到相关题目")
|
|
|
except Exception as e:
|
|
|
print(f"查询错误: {str(e)}")
|
|
|
|
|
|
|
|
|
# ================== 测试执行 ==================
|
|
|
if __name__ == '__main__':
|
|
|
test_cases = [
|
|
|
"小明用50元买了3本笔记本，每本8元，还剩多少钱？",
|
|
|
"甲乙两车相距300公里，甲车速度60km/h，乙车40km/h，几小时后相遇？"
|
|
|
]
|
|
|
|
|
|
for q in test_cases:
|
|
|
print("\n" + "=" * 60)
|
|
|
analyzer = ProblemAnalyzer(q)
|
|
|
analyzer.execute()
|
|
|
|
|
|
query_question('6fff79108736') |
