main
HuangHai 3 weeks ago
parent 6ae9fd4d6e
commit e5b714df41

@ -27,3 +27,7 @@ JIEBA_CUSTOM_WORDS = ['文言虚词', '花呗']
MODEL_PATH = "D:/Tencent_AILab_ChineseEmbedding/Tencent_AILab_ChineseEmbedding.txt"
# 加载词向量模型时限制的词汇数量
MODEL_LIMIT = 10000
# NEO4J数据库配置
NEO4J_URI = "bolt://localhost:7687"
NEO4J_AUTH = ("neo4j", "DsideaL147258369")

@ -0,0 +1,12 @@
from Config.Config import *
from Neo4j.Neo4jExecutor import *
# 使用示例
if __name__ == '__main__':
executor = Neo4jExecutor(
uri=NEO4J_URI,
auth=NEO4J_AUTH
)
# 清库
clear(executor.graph)
print("清库成功")

@ -0,0 +1,61 @@
import json
from Neo4j.Neo4jExecutor import *
def json_to_cypher(data):
"""将知识体系JSON转换为Cypher插入脚本"""
cypher = []
seen = set()
def process_node(node, parent_id=None):
nonlocal seen
node_id = node['value']
node_name = node['title'].replace("'", "''")
# 创建当前节点
if node_id not in seen:
cypher.append(f"MERGE (n:KnowledgePoint {{id: '{node_id}'}}) SET n.name = '{node_name}';")
seen.add(node_id)
# 创建父子关系
if parent_id:
cypher.append(f"""
MATCH (parent:KnowledgePoint {{id: '{parent_id}'}}),
(child:KnowledgePoint {{id: '{node_id}'}})
MERGE (parent)-[:HAS_SUB_POINT]->(child);""")
# 递归处理子节点
if 'children' in node and not node['isLeaf']:
for child in node['children']:
process_node(child, parent_id=node_id)
# 处理根节点
for root in data['data']['tree']:
process_node(root)
# 处理根节点的父级关系(如果有)
if root.get('parentValue'):
cypher.append(f"MERGE (parent:KnowledgePoint {{id: '{root['parentValue']}'}});")
cypher.append(f"""
MATCH (parent:KnowledgePoint {{id: '{root['parentValue']}'}}),
(child:KnowledgePoint {{id: '{root['value']}'}})
MERGE (parent)-[:HAS_SUB_POINT]->(child);""")
return '\n'.join(cypher)
# 使用示例
if __name__ == '__main__':
executor = Neo4jExecutor(
uri=NEO4J_URI,
auth=NEO4J_AUTH
)
# 清库
clear(executor.graph)
# 这里替换成你的JSON数据变量
with open('小学数学知识点体系.json', 'r',encoding='utf-8') as f:
your_json_data = json.load(f)
cypherText=json_to_cypher(your_json_data)
executor.execute_cypher_text(cypherText)

@ -0,0 +1,137 @@
import json
from Neo4j.Neo4jExecutor import *
# Neo4j连接配置
graph = Graph(NEO4J_URI, auth=NEO4J_AUTH)
class Py2neoLoader:
def __init__(self):
self.node_cache = {}
self.tx = graph.begin() # 初始化事务
def create_literacy_nodes(self, data):
try:
print("Received data structure keys:", data.keys())
# 创建核心素养节点
if "tree" in data and len(data["tree"]) > 0:
self._create_core_node(data["tree"][0])
else:
raise ValueError("Invalid data structure: missing 'tree' array")
# 创建关联体系节点(处理第二个节点)
if len(data["tree"]) > 1:
self._create_relation_system(data["tree"][1])
graph.commit(self.tx) # 替换 self.tx.commit()
print(f"数据导入成功!共处理{len(self.node_cache)}个节点")
except Exception as e:
graph.rollback(self.tx) # 替换 self.tx.rollback()
print("主流程错误:", str(e))
raise
def _create_core_node(self, node):
try:
core_node = Node("CoreLiteracy",
title=node.get("title", "未命名节点"),
value=node.get("value", "CORE_DEFAULT"),
key=node.get("key", "ROOT_DEFAULT"))
self.tx.merge(core_node, "CoreLiteracy", "value")
self.node_cache[node.get("value")] = core_node
print(f"创建核心节点: {core_node}")
if "children" in node:
for child in node["children"]:
self._create_child_node(child, core_node)
except Exception as e:
print(f"创建核心节点出错: {str(e)}")
print("问题节点数据:", node)
raise
def _create_child_node(self, node, parent):
try:
if "value" not in node:
node["value"] = f"AUTO_VALUE_{len(self.node_cache) + 1}"
print(f"为节点生成默认value: {node['value']}")
child_node = Node("LiteracyNode",
title=node.get("title", "未命名子节点"),
value=node["value"],
key=node.get("key", ""),
parentValue=node.get("parentValue", ""),
preSkills=node.get("preSkills", []))
self.tx.merge(child_node, "LiteracyNode", "value")
self.node_cache[node["value"]] = child_node
if parent is not None:
rel = Relationship(parent, "HAS_SUB_NODE", child_node)
self.tx.merge(rel)
print(f"创建关系: {parent['value']} -> {child_node['value']}")
# 处理前置技能关系
for pre_skill in node.get("preSkills", []):
if pre_skill in self.node_cache:
pre_node = self.node_cache[pre_skill]
rel = Relationship(pre_node, "REQUIRES", child_node)
self.tx.merge(rel)
else:
print(f"警告: 前置技能节点 {pre_skill} 不存在")
# 递归处理子节点
if "children" in node:
for sub_child in node.get("children", []):
self._create_child_node(sub_child, child_node)
except Exception as e:
print(f"创建子节点出错: {str(e)}")
print("问题节点数据:", node)
raise
def _create_relation_system(self, relation_system):
try:
# 创建关联体系根节点
sys_node = Node("RelationSystem",
title=relation_system.get("title", "未命名关联体系"),
value=relation_system.get("value", "REL_SYS_DEFAULT"),
path=relation_system.get("path", []))
self.tx.merge(sys_node, "RelationSystem", "value")
print(f"创建关联体系节点: {sys_node}")
# 处理关联链
for chain in relation_system.get("children", []):
chain_node = Node("RelationChain",
title=chain.get("title", "未命名关联链"),
value=chain.get("value", f"CHAIN_{len(self.node_cache) + 1}"),
path=chain.get("path", []))
self.tx.merge(chain_node, "RelationChain", "value")
self.tx.merge(Relationship(sys_node, "HAS_CHAIN", chain_node))
# 处理路径关系
for path_str in chain.get("path", []):
nodes = [n.strip() for n in path_str.replace("+", "").split("")]
for i in range(len(nodes) - 1):
source = self.node_cache.get(nodes[i])
target = self.node_cache.get(nodes[i + 1])
if source and target:
rel = Relationship(source, "NEXT_STEP", target)
self.tx.merge(rel)
else:
print(f"路径节点缺失: {nodes[i]}{nodes[i + 1]}")
except Exception as e:
print(f"创建关联体系出错: {str(e)}")
print("问题数据:", relation_system)
raise
if __name__ == "__main__":
try:
with open("小学数学学科素养点体系.json", 'r', encoding='utf-8') as f:
raw_data = json.load(f)
print("JSON文件加载成功顶层键:", raw_data.keys())
if "data" not in raw_data:
raise ValueError("JSON缺少'data'字段")
loader = Py2neoLoader()
loader.create_literacy_nodes(raw_data["data"])
except Exception as e:
print("主程序错误:", str(e))

@ -0,0 +1,296 @@
# -*- 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元还剩多少钱", # 知识点:四则运算应用 素养点:数学运算能力
# 几何问题
"一个长方形花坛长5米宽3米四周铺1米宽的小路求小路面积", # 知识点:面积计算 素养点:空间观念
# 统计概率
"某班30人数学成绩90分以上占1/580-89分占1/3求80分以下人数", # 知识点:分数运算 素养点:数据分析
# 典型应用题
"甲乙两车相距300公里甲车速度60km/h乙车40km/h几小时后相遇", # 知识点:相遇问题 素养点:数学建模
# 方程应用
"鸡兔同笼头共10个脚共28只问鸡兔各多少", # 知识点:二元一次方程 素养点:代数思维
# 比例问题
"配制农药药液药粉和水的比例是3:100现有水500kg需要多少药粉", # 知识点:比例应用 素养点:量化分析
# 函数图像
"某物体做匀加速运动初速度2m/s加速度0.5m/s²写出速度v与时间t的关系式", # 知识点:一次函数 素养点:数形结合
# 立体几何
"圆柱形水桶底面半径0.4米高1.2米求它的容积π取3.14", # 知识点:圆柱体积 素养点:空间想象
# 概率统计
"掷两个骰子点数和为7的概率是多少", # 知识点:概率计算 素养点:数据预测
# 工程问题
"甲队单独完成工程需20天乙队需30天两队合作需要多少天", # 知识点:工程问题 素养点:模型构建
# 最优化问题
"用20米篱笆围矩形菜地怎样围面积最大最大面积是多少", # 知识点:二次函数 素养点:优化思想
# 利率问题
"本金10000元年利率3.5%存3年到期本息合计多少", # 知识点:单利计算 素养点:金融素养
# 数列问题
"等差数列首项5公差3求第10项的值", # 知识点:等差数列 素养点:模式识别
# 测量问题
"在比例尺1:5000的地图上2cm线段代表实际距离多少米", # 知识点:比例尺应用 素养点:单位换算
# 逻辑推理
"A说B在说谎B说C在说谎C说AB都在说谎问谁在说真话" # 知识点:逻辑推理 素养点:批判性思维
]
for q in test_cases:
print("\n" + "=" * 60)
analyzer = ProblemAnalyzer(q)
analyzer.execute()

@ -0,0 +1,61 @@
from py2neo import Graph
import json
from Config import *
def query_all_questions():
# Neo4j连接配置
neo4j_config = {
"uri": NEO4J_URI, # 从Config导入
"auth": NEO4J_AUTH # 从Config导入
}
# 初始化图数据库连接
graph = Graph(**neo4j_config)
try:
# 获取所有试题ID
question_ids = graph.run(
"MATCH (q:Question) RETURN q.id AS question_id"
).data()
results = []
# 遍历每个试题
for record in question_ids:
qid = record['question_id']
# 修改查询部分
data = graph.run("""
MATCH (q:Question {id: $qid})
OPTIONAL MATCH (q)-[:REQUIRES_KNOWLEDGE]->(kp:KnowledgePoint)
OPTIONAL MATCH (q)-[:DEVELOPS_LITERACY]->(lp:LiteracyNode)
RETURN
q.content AS content,
collect(DISTINCT {id: kp.id, name: kp.name}) AS knowledge_points,
collect(DISTINCT {id: lp.value, title: lp.title}) AS literacy_points
""", qid=qid).data()
if data:
result = {
"question_id": qid,
"content": data[0]['content'],
"knowledge_points": data[0]['knowledge_points'],
"literacy_points": data[0]['literacy_points']
}
results.append(result)
# 增强版输出展示
print(f"\n{'=' * 40} 题目详情 {'=' * 40}")
print(f"📚 试题ID: {qid}")
print(f"📝 内容全文: {result['content']}") # 新增完整内容输出
print(f"🔍 内容摘要: {result['content'][:50]}...") # 保留摘要显示
print(f"🧠 知识点: {[kp['name'] for kp in result['knowledge_points']]}")
print(f"🆔 知识点ID: {[kp['id'] for kp in result['knowledge_points']]}")
print(f"🌟 素养点: {[lp['title'] for lp in result['literacy_points']]}")
print(f"🔢 素养点ID: {[lp['id'] for lp in result['literacy_points']]}")
print('=' * 90)
except Exception as e:
print(f"❌ 查询失败: {str(e)}")
if __name__ == '__main__':
query_all_questions()

@ -0,0 +1,107 @@
import re
from Config import *
from py2neo import Graph, Node, Relationship, Subgraph
from typing import List, Tuple
def clear(db):
# 清空数据
db.run("MATCH (n) DETACH DELETE n")
# 分步删除约束和索引
try:
# 删除约束
constraints = db.run("SHOW CONSTRAINTS YIELD name").data()
for constr in constraints:
db.run(f"DROP CONSTRAINT `{constr['name']}`")
# 删除索引
indexes = db.run("SHOW INDEXES YIELD name, type WHERE type <> 'LOOKUP'").data()
for idx in indexes:
db.run(f"DROP INDEX `{idx['name']}`")
except Exception as e:
print(f"删除操作失败: {e}")
def create_subgraph(db: Graph, nodes: List[Node], relations: List[Tuple[Node, str, Node]]) -> None:
"""统一创建子图"""
subgraph = Subgraph(
nodes=nodes,
relationships=[Relationship(start, rel_type, end) for start, rel_type, end in relations]
)
db.create(subgraph)
def tx_create(db: Graph, nodes: List[Node], relations: List[Tuple[Node, str, Node]]) -> None:
"""事务方式创建数据"""
try:
tx = db.begin()
subgraph = Subgraph(
nodes=nodes,
relationships=[Relationship(start, rel_type, end) for start, rel_type, end in relations]
)
tx.create(subgraph)
db.commit(tx)
except Exception as e:
db.rollback(tx)
print(f"事务操作失败: {str(e)}")
raise
class Neo4jExecutor:
def __init__(self, uri, auth):
self.graph = Graph(uri, auth=auth)
# 新增文本执行方法
def execute_cypher_text(self, cypher_text: str) -> dict:
"""直接执行Cypher文本"""
stats = {'total': 0, 'success': 0, 'failed': 0}
try:
statements = re.split(r';\s*\n', cypher_text)
statements = [s.strip() for s in statements if s.strip()]
stats['total'] = len(statements)
for stmt in statements:
try:
self.graph.run(stmt)
stats['success'] += 1
except Exception as e:
stats['failed'] += 1
print(f"执行失败: {stmt[:50]}... \n错误: {str(e)[:100]}")
return stats
except Exception as e:
print(f"执行失败: {stmt[:100]}... \n完整错误: {str(e)}") # 原为str(e)[:100]
return stats
def execute_cypher_file(self, file_path: str) -> dict: # 确保方法名称正确
"""执行Cypher文件"""
stats = {'total': 0, 'success': 0, 'failed': 0}
try:
with open(file_path, 'r', encoding='utf-8') as f:
cypher_script = f.read()
statements = re.split(r';\s*\n', cypher_script)
statements = [s.strip() for s in statements if s.strip()]
stats['total'] = len(statements)
for stmt in statements:
try:
self.graph.run(stmt)
stats['success'] += 1
except Exception as e:
stats['failed'] += 1
print(f"执行失败: {stmt[:50]}... \n错误: {str(e)[:100]}")
return stats
except Exception as e:
print(f"文件错误: {str(e)}")
return stats
def init():
executor = Neo4jExecutor(
uri=NEO4J_URI,
auth=NEO4J_AUTH
)
# 清库
clear(executor.graph)

@ -0,0 +1,160 @@
{
"status": 200,
"data": {
"tree": [
{
"children": [
{
"title": "数感培养",
"value": "MATH_LITERACY_01",
"key": "NUM_SENSE",
"children": [
{
"title": "数量感知基础1-2年级",
"value": "SUB_01",
"key": "NUM_BASIC",
"parentValue": "MATH_LITERACY_01",
"preSkills": []
},
{
"title": "数运算直观3-4年级",
"value": "SUB_02",
"key": "NUM_OPERATION",
"parentValue": "MATH_LITERACY_01",
"preSkills": ["SUB_01"]
},
{
"title": "数关系抽象5-6年级",
"value": "SUB_03",
"key": "NUM_RELATION",
"parentValue": "MATH_LITERACY_01",
"preSkills": ["SUB_02"]
}
]
},
{
"title": "空间观念",
"value": "MATH_LITERACY_02",
"key": "SPACE_CONCEPT",
"children": [
{
"title": "图形辨识1-2年级",
"value": "SUB_04",
"key": "SHAPE_ID",
"parentValue": "MATH_LITERACY_02",
"preSkills": []
},
{
"title": "空间方位3-4年级",
"value": "SUB_05",
"key": "SPACE_ORIENT",
"parentValue": "MATH_LITERACY_02",
"preSkills": ["SUB_04"]
},
{
"title": "几何推理5-6年级",
"value": "SUB_06",
"key": "GEOM_REASON",
"parentValue": "MATH_LITERACY_02",
"preSkills": ["SUB_05"]
}
]
},
{
"title": "运算思维",
"value": "MATH_LITERACY_03",
"key": "OPERATION_THINK",
"children": [
{
"title": "算法理解1-2年级",
"value": "SUB_07",
"key": "ALGORITHM",
"parentValue": "MATH_LITERACY_03",
"preSkills": ["SUB_01"]
},
{
"title": "运算策略3-4年级",
"value": "SUB_08",
"key": "STRATEGY",
"parentValue": "MATH_LITERACY_03",
"preSkills": ["SUB_07"]
},
{
"title": "灵活运算5-6年级",
"value": "SUB_09",
"key": "FLEX_CALC",
"parentValue": "MATH_LITERACY_03",
"preSkills": ["SUB_08"]
}
]
},
{
"title": "数据意识",
"value": "MATH_LITERACY_04",
"key": "DATA_LITERACY",
"children": [
{
"title": "简单统计3-4年级",
"value": "SUB_10",
"key": "BASIC_STATS",
"parentValue": "MATH_LITERACY_04",
"preSkills": ["SUB_02"]
},
{
"title": "数据分析5-6年级",
"value": "SUB_11",
"key": "DATA_ANALYSIS",
"parentValue": "MATH_LITERACY_04",
"preSkills": ["SUB_10"]
}
]
},
{
"title": "建模能力",
"value": "MATH_LITERACY_05",
"key": "MODELING",
"children": [
{
"title": "问题数学化4-5年级",
"value": "SUB_12",
"key": "PROBLEM_TRANS",
"parentValue": "MATH_LITERACY_05",
"preSkills": ["SUB_08", "SUB_05"]
},
{
"title": "模型构建5-6年级",
"value": "SUB_13",
"key": "MODEL_BUILD",
"parentValue": "MATH_LITERACY_05",
"preSkills": ["SUB_12"]
}
]
}
],
"title": "数学核心素养",
"value": "CORE_LITERACY",
"key": "ROOT"
},
{
"title": "素养关联体系",
"children": [
{
"title": "基础素养链",
"value": "CHAIN_01",
"path": ["SUB_01 → SUB_02 → SUB_03 → SUB_07 → SUB_08 → SUB_09"]
},
{
"title": "空间素养链",
"value": "CHAIN_02",
"path": ["SUB_04 → SUB_05 → SUB_06 → SUB_12"]
},
{
"title": "综合应用链",
"value": "CHAIN_03",
"path": ["SUB_09 + SUB_06 → SUB_13"]
}
]
}
]
}
}

File diff suppressed because it is too large Load Diff

@ -0,0 +1,30 @@
# Neo4J下载安装
https://blog.csdn.net/weixin_44455665/article/details/141463014
解压缩到D:\neo4j-community-5.26.2\bin
# 安装服务
cd D:\neo4j-community-5.26.2\bin
neo4j windows-service install
neo4j start
打开 conf/neo4j.conf 文件,修改以下配置:
# 允许远程连接
server.default_listen_address=0.0.0.0
# 访问
http://10.10.21.20:7474
neo4j
DsideaL4r5t6y7u
密码默认neo4j
# 停止服务
neo4j stop
neo4j windows-service uninstall
# 通过python操作neo4j
https://blog.csdn.net/sinat_20471177/article/details/134056788
# 提示词
生成小学数学的所有知识点和能力点我需要保存到cypher的脚本如果过多无法一次性输出就只输出两个年级或三个年级的我再追问后返回其余部分
Loading…
Cancel
Save