An intelligent teaching experiment method, platform and medium

Abstract

The application relates to an intelligent teaching experiment method, platform and medium, and belongs to the technical field of data processing. A course portal shows a course list and details to students, and a detail page integrates a course directory, a knowledge graph and video teaching resources. After a student selects an experiment task, the system calls an integrated experiment environment integrating an experiment guide, a code editor, a running terminal and AI computing power. Experiment learning objectives and prerequisite knowledge are extracted in combination with a course knowledge graph, and an initial cognitive portrait is constructed according to historical learning data of the student. Time-sequential structured data such as code operation, running logs and interface interaction are collected in real time during the experiment, operation error sources are diagnosed, and the real-time cognitive portrait of the student is dynamically updated. Personalized learning paths are generated relying on the learning portrait, learning objectives and the knowledge graph, and non-intrusive learning guidance is issued. The long-term knowledge mastery degree of the student is updated after the task is completed. The application can accurately adapt to individual learning conditions, and improves the efficiency of intelligent experiment teaching and the learning effect of students.

Description

Technical Field

[0001] This application relates to the field of data processing technology, and in particular to an intelligent teaching experiment method, platform and medium. Background Technology

[0002] Currently, the conventional teaching experiment method mainly adopts the "theoretical explanation + independent experiment" model, which is implemented as follows: Teachers explain the course theory, experimental objectives, and operating procedures to students through offline classrooms or online course portals, and provide experimental guidance documents for students to refer to; students complete the experimental tasks according to the guidance documents after class or in the laboratory, using independent experimental tools (such as locally installed code editors, experimental equipment, etc.); if students encounter problems during the experiment, they need to seek help through offline inquiries with teachers, online messages, etc., and teachers provide targeted answers based on the problems described by students; after completing the experiment, students submit experimental reports, and teachers understand the students' experimental completion status by grading the reports, and make a rough assessment of the students' knowledge mastery based on the report feedback. At the same time, the experimental reports and grading results are compiled and archived as a reference for subsequent teaching.

[0003] While the scheme can complete basic teaching experiments, it is difficult to collect data on students' experimental process in real time, and the diagnosis of experimental errors remains superficial, making it difficult to improve teaching efficiency and students' learning outcomes. Summary of the Invention

[0004] To improve teaching efficiency and student learning outcomes, this application provides an intelligent teaching experiment method, platform, and medium.

[0005] Firstly, this application provides an intelligent teaching experiment method, which adopts the following technical solution: An intelligent teaching experiment method includes: The course portal presents a course list and a course details page to student users. The course details page integrates and displays the course catalog, course knowledge graph, and course video explanations. In response to a student's selection of a specific experimental task on the course details page, an integrated experimental environment matching the specific experimental task is invoked. The integrated experimental environment integrates experimental documentation guidance, a code editor, a running terminal, and underlying AI computing resources. In the integrated experimental environment, the learning objective set and the prior knowledge subgraph corresponding to the specific experimental task are extracted according to the course knowledge graph, and the historical mastery score of the student for each knowledge node in the prior knowledge subgraph is calculated based on the student's historical interaction data to construct the student's initial cognitive profile. When the student performs the specific experimental task in the integrated experimental environment according to the experimental document, the integrated experimental environment collects the student's code operation sequence, program runtime log, computing resource access sequence and user interface interaction events in real time, and converts them into a structured event sequence ordered by time. Based on the structured event sequence and the course knowledge graph, root cause diagnosis is performed on the errors made by the students during the execution of the specific experimental task, and a set of root cause hypotheses is generated. Based on the root cause hypothesis set and the student's successful behavior records during the execution of the specific experimental task, the student's initial cognitive profile is updated to obtain the student's real-time cognitive profile. Based on the real-time cognitive profile, the learning objectives of the specific experimental task, and the course knowledge graph, an optimal learning path sequence is generated for the student. Based on the optimal learning path sequence and the student's current context in the integrated experimental environment, corresponding non-intrusive guidance instructions are generated and presented. After the student completes the guidance instructions, the mastery level of the corresponding knowledge node in the student's long-term cognitive profile is updated according to the student's completion effect, and the entire process data is stored in the teaching data center.

[0006] By adopting the above-mentioned technical solutions, the limitations of the separation between knowledge explanation and experimental operation in traditional teaching are broken. The course knowledge graph is deeply integrated with the integrated experimental environment, allowing students to establish clear knowledge connections before experiments begin. Simultaneously, relying on AI computing power to support real-time data collection and analysis capabilities, every step of the student's behavior during the experiment is captured. The entire chain of data, from code writing to resource retrieval, can be transformed into analyzable structured information, enabling precise root cause diagnosis of experimental errors. This goes beyond simply correcting surface problems; it delves into weak areas of knowledge acquisition, providing targeted guidance. Furthermore, through continuously iterative cognitive profile construction, it can dynamically adapt to students' learning progress and ability levels. From initial cognitive assessment to real-time profile updates and long-term cognitive accumulation, the learning path always aligns with students' individual needs. This avoids experimental blockages caused by knowledge gaps and effectively taps into students' learning potential, ultimately achieving a dual improvement in teaching efficiency and learning outcomes. The accumulated full-process teaching data also provides solid data support for subsequent course optimization and teaching method iteration, promoting the transformation of teaching models from standardization to personalization.

[0007] Optionally, the step of performing root cause diagnosis on errors made by students during the execution of the specific experimental task, based on the structured event sequence and the course knowledge graph, and generating a set of root cause hypotheses, specifically includes: The error events in the structured event sequence are matched with the predefined error pattern nodes in the course knowledge graph to obtain a set of matched error patterns; For each error pattern in the set of matched error patterns, a reverse search is performed along the causal relationship edges in the course knowledge graph until the knowledge node or skill node that is the root cause is located, and the confidence of each root cause node is calculated to generate the set of root cause hypotheses.

[0008] Optionally, the step of matching error events in the structured event sequence with predefined error pattern nodes in the course knowledge graph specifically includes: Extract the features of the error event, wherein the features include at least the error type and the error code context; Calculate the similarity between the error event features and the features of each error pattern node in the course knowledge graph; If the similarity exceeds a preset matching threshold, it is determined that the error event and the error pattern node are successfully matched.

[0009] By employing the aforementioned technical solution, and extracting core features such as error type and error code context, scattered error events during student experiments are transformed into quantifiable and analyzable structured information. This avoids the vague judgments and empirical attributions of errors found in traditional teaching. Furthermore, relying on similarity calculation and threshold determination mechanisms, a precise mapping is established between error events and predefined error patterns in the knowledge graph. This ensures that each specific error corresponds to a clearly defined knowledge gap or operational error within the course's knowledge system, rather than an isolated problem manifestation. This helps students solve problems at their root and prevents the recurrence of similar errors.

[0010] Optionally, the step of performing a reverse search along the causal relationship edges in the course knowledge graph for each error pattern in the set of matched error patterns specifically includes: Starting from the matched error pattern node, perform a reverse breadth-first search along the causal and dependency relationship edges in the course knowledge graph; The search will stop when the search depth reaches the preset maximum depth or when the search reaches a knowledge node or skill node that no longer has a prerequisite relationship. Mark all knowledge nodes or skill nodes encountered during the search process as candidate root cause nodes; Calculate the confidence score for each candidate root cause node based on the path length from the candidate root cause node to the starting error mode node and the weight of the relationships on the path.

[0011] Optionally, the step of generating the optimal learning path sequence for the student based on the real-time cognitive profile, the learning objectives of the specific experimental task, and the course knowledge graph specifically includes: Using the learning objective of the specific experimental task as the endpoint and the knowledge nodes already mastered by the student as the starting point, a weighted path search graph is constructed by combining the mastery scores of each knowledge node in the student's real-time cognitive profile, the inherent difficulty value of the knowledge node in the course knowledge graph, and the estimated learning time. In the path search graph, the path with the minimum cumulative cost from the starting point to the ending point is searched to generate the optimal learning path sequence; Each knowledge node in the optimal learning path sequence is transformed into a specific guiding instruction, and based on the student's current code context in the integrated experimental environment, corresponding non-intrusive code prompts and learning resource recommendations are generated and presented in real time in the user interface of the integrated experimental environment.

[0012] By adopting the above technical solutions, path planning is no longer based on subjective judgments based on experience, but rather on multi-dimensional data calculations. This ensures that the generated path not only matches the student's current cognitive level but also steadily progresses towards the predetermined learning goals. By searching for the path with the minimum cumulative cost, the system can filter out the most efficient paths for knowledge acquisition and skill improvement for students, avoiding ineffective repetitive learning or excessively large knowledge gaps. At the same time, the knowledge nodes in the path are transformed into non-intrusive guidance instructions and learning resource recommendations that are combined with the current code context. This makes learning guidance no longer a rigid task assignment, but a precise assistance integrated into the experimental process. Students are not interrupted in their experimental thinking while receiving prompts, and can gradually fill knowledge gaps and improve experimental skills in a natural and smooth operation.

[0013] Optionally, the steps for constructing a weighted path search graph specifically include: Determine the node set of the path search graph, the node set containing all knowledge nodes, skill nodes and teaching resource nodes related to the specific experimental task; Based on the "prerequisite knowledge" relationship in the course knowledge graph, the directed edges between nodes in the node set are determined, and the direction indicates the learning order. Calculate the weight for each directed edge. The weight is calculated as follows: weight = w1 × inherent difficulty value of the target node × [(100 - student's mastery of the source node) / 100] + w2 × (estimated learning time of the target node / total estimated time of a single experiment), where w1 and w2 are preset weight coefficients used to balance cognitive difficulty and time cost.

[0014] Optionally, the step of updating the mastery level of the corresponding knowledge node in the student's long-term cognitive profile based on the student's performance specifically includes: Calculate the learning effectiveness score based on the student's completion of the guidance instructions; A dynamic weighted fusion algorithm is adopted to merge the current learning effectiveness score with the original long-term mastery score of the corresponding knowledge node. The dynamic weighted fusion algorithm is: New mastery = (Original mastery × Credibility parameter + Learning effectiveness score) / (Creativity parameter + 1), where the credibility parameter increases with the increase of the number of times the corresponding knowledge node is learned.

[0015] Optionally, the intelligent teaching experiment method also includes a system knowledge evolution process based on the accumulation of teaching data, which is monitored and driven by the administrator user through the console. The learning performance data of all students at each knowledge node is collected from the teaching data center, and the average performance of the group is calculated. If the average effectiveness of a certain knowledge node is consistently lower than the preset effectiveness threshold, the corresponding knowledge node will be marked as a teaching difficulty and a review prompt will be generated in the console. If a stable and unrecorded new pattern is formed by analyzing frequently occurring "error-fix" event pairs, a candidate error pattern node is generated in the console. Continuously collect new content from preset external information sources, obtain candidate knowledge triples through information extraction technology, and calculate the corresponding confidence scores; The teaching difficulty prompts, candidate error pattern nodes, and candidate knowledge triples with confidence scores are pushed to expert users for review on the console. New knowledge nodes, new relationship edges, and associated teaching resources that expert users confirm as valid in the console will be officially merged and updated into the main knowledge graph and course resource library.

[0016] By adopting the above technical solutions, the subjectivity of judging weak points in teaching based solely on teachers' experience is avoided in traditional teaching. Simultaneously, by analyzing high-frequency "error-fix" event pairs, new problems and misconceptions emerging during student learning can be captured in a timely manner, continuously enriching the error pattern reserves in the course knowledge graph and enhancing the targeted nature of teaching guidance. Furthermore, the setting of collecting new content from external information sources and extracting candidate knowledge triplets ensures the openness of the course knowledge system, promptly incorporating cutting-edge knowledge and industry practice, and avoiding the lag in the knowledge system. The entire process, through a dual mechanism of administrator monitoring and expert review, ensures both the scientific rigor and accuracy of knowledge updates, and enables the rapid integration of verified new knowledge and error patterns into the main knowledge graph and course resource library.

[0017] Secondly, this application provides an intelligent teaching experiment platform, which adopts the following technical solution: An intelligent teaching experiment platform includes: The course portal module is used to present a course list and course details page to student users. The course details page integrates and displays the course catalog, course knowledge graph and course video explanations. The environment invocation module is used to respond to the student's selection of a specific experimental task on the course details page, and invoke an integrated experimental environment that matches the specific experimental task. The integrated experimental environment integrates experimental document guidance, code editor, running terminal and underlying AI computing power resources. The profile initialization module is used in the integrated experimental environment to extract the learning target set and the prior knowledge subgraph corresponding to the specific experimental task according to the course knowledge graph, and to calculate the student's historical mastery score of each knowledge node in the prior knowledge subgraph according to the student's historical interaction data, so as to construct the student's initial cognitive profile. The data acquisition and processing module is used to collect the student's code operation sequence, program runtime log, computing resource access sequence and user interface interaction events in real time through the integrated experimental environment when the student performs the specific experimental task in the integrated experimental environment according to the experimental document instructions, and convert them into a structured event sequence ordered by time. The root cause diagnosis module is used to perform root cause diagnosis on the errors made by the students during the execution of the specific experimental task based on the structured event sequence and the course knowledge graph, and generate a set of root cause hypotheses. The real-time cognitive profile update module is used to update the student's initial cognitive profile based on the root cause hypothesis set and the student's successful behavior records during the execution of the specific experimental task, so as to obtain the student's real-time cognitive profile. The path planning and guidance module is used to generate an optimal learning path sequence for the student based on the real-time cognitive profile, the learning objectives of the specific experimental task, and the course knowledge graph, and to generate and present corresponding non-intrusive guidance instructions based on the optimal learning path sequence and the student's current context in the integrated experimental environment. The long-term profile update and data accumulation module is used to update the mastery of the corresponding knowledge nodes in the student's long-term cognitive profile according to the student's completion effect after the student completes the guidance instructions, and to accumulate the entire process data into the teaching data center.

[0018] Thirdly, this application provides a computer-readable storage medium, which adopts the following technical solution: A computer-readable storage medium storing a computer program that can be loaded by a processor and executed as described in the first aspect of the intelligent teaching experiment method.

[0019] In summary, this application includes at least one of the following beneficial technical effects: 1. By integrating the course knowledge graph with the integrated AI experimental environment, the system collects student experimental operation behavior data across the entire process, accurately identifies the underlying knowledge root causes of errors, dynamically iterates student cognitive profiles, and generates non-intrusive personalized learning guidance that fits the experimental scenario. This solves the problem of the disconnect between knowledge explanation and experimental operation, avoids knowledge gaps, achieves personalized teaching that adapts to students' abilities, and improves learning and teaching efficiency.

[0020] 2. Based on the learning data of all students accumulated in the teaching data center, a knowledge graph self-updating mechanism is constructed. This mechanism automatically identifies teaching difficulties, discovers new error patterns, and introduces cutting-edge external subject knowledge. After expert review, the knowledge system is iterated, breaking away from the limitations of traditional teaching that relies on human experience to optimize courses. This continuously improves teaching resources and knowledge systems, supporting the long-term upgrading of teaching models. Attached Figure Description

[0021] Figure 1 This is a first flowchart of an embodiment of the method of this application; Figure 2 This is a second flowchart of an embodiment of the method of this application; Figure 3 This is a third flowchart of an embodiment of the method of this application; Figure 4 This is the fourth flowchart of an embodiment of the method of this application; Figure 5 This is the fifth flowchart of an embodiment of the method of this application; Figure 6 This is the sixth flowchart of an embodiment of the method of this application. Detailed Implementation

[0022] To make the purpose, technical solution, and advantages of this application clearer, the following description is provided in conjunction with the appendix. Figures 1-6 The present application will be further described in detail below with reference to embodiments. It should be understood that the specific embodiments described herein are for illustrative purposes only and are not intended to limit the scope of the application.

[0023] The first embodiment of this application discloses an intelligent teaching experiment method. (Refer to...) Figure 1 The intelligent teaching experimental method includes S110-S180: S110 presents a course list and course details page to student users in the course portal. The course details page integrates and displays the course catalog, course knowledge graph and course video explanations. S120 responds to students' selection of specific experimental tasks on the course details page by calling up an integrated experimental environment that matches the specific experimental task. The integrated experimental environment integrates experimental document guidance, code editor, running terminal and underlying AI computing power resources. S130, in the integrated experimental environment, the set of learning objectives and the prior knowledge subgraph corresponding to the specific experimental task are extracted according to the course knowledge graph, and the historical mastery score of each knowledge node in the prior knowledge subgraph is calculated based on the student's historical interaction data to construct the student's initial cognitive profile. S140: When students perform specific experimental tasks in the integrated experimental environment according to the experimental documentation, the integrated experimental environment collects students' code operation sequences, program runtime logs, computing resource access sequences and user interface interaction events in real time, and converts them into a structured event sequence ordered by time. S150, based on structured event sequences and course knowledge graphs, performs root cause diagnosis on errors made by students during the execution of specific experimental tasks, and generates a set of root cause hypotheses. S160, based on the root cause hypothesis set and the student's successful behavior records during the execution of a specific experimental task, update the student's initial cognitive profile to obtain the student's real-time cognitive profile. S170 generates the optimal learning path sequence for students based on real-time cognitive profiles, learning objectives for specific experimental tasks, and course knowledge graphs. Based on the optimal learning path sequence and the current context of students in the integrated experimental environment, it generates and presents corresponding non-intrusive guidance instructions. S180 updates the mastery of the corresponding knowledge nodes in the student's long-term cognitive profile based on the student's performance after the student completes the guidance instructions, and stores the entire process data in the teaching data center.

[0024] Specifically, for step S110, a front-end and back-end separation architecture was used to build the course portal. The front-end used the Vue3 + Element Plus framework to develop the user interface, ensuring smooth page response and adaptability to different terminals (computers, tablets). The back-end used the Spring Boot framework to provide interface services, and MySQL was used to store course-related data. The course list page displays courses according to the dimensions of "course category - course name - difficulty level - number of experiments," supporting fuzzy search and category filtering. Each course entry has a "view details" button, which redirects to the course details page. The course details page uses a three-column layout. The left side is the course catalog, displayed hierarchically by chapter, supporting expand / collapse. Each catalog node is associated with a corresponding experimental task entry. The middle area is the course knowledge graph, built using the Neo4j graph database and visualized using ECharts' force-directed graph. Knowledge nodes are categorized by "knowledge point - skill point - experimental task," distinguished by different colors. Directed edges between nodes are labeled with relationships such as "prerequisite knowledge" and "related skills." Clicking on a node allows you to view detailed explanations and related resources. The right side contains course video lectures, using the HLS protocol for streaming playback, supporting playback speed (0.5x-2.0x), resume playback, and subtitle switching. Video resources are stored in Alibaba Cloud OSS object storage, with CDN acceleration ensuring smooth playback. Additionally, links to corresponding knowledge point documents are linked below the videos for easy access by students.

[0025] For step S120, the frontend sends an asynchronous request via Axios to respond to the student's selection of a specific experimental task on the course details page. The request parameters include the experimental task ID, course ID, and student ID. After receiving the request, the backend matches the corresponding integrated experimental environment configuration information (pre-stored in the database, including environment type, required computing power, dependent tools, etc.) using the experimental task ID. The integrated experimental environment is deployed using Docker containers to ensure environment consistency and portability. Corresponding base images are configured for different types of experiments (such as Python programming, deep learning, and hardware simulation). For example, the Python experimental image integrates Python 3.9, the PyCharm Community Edition plugin, and commonly used third-party libraries (numpy, pandas, etc.), while the deep learning experimental image integrates the TensorFlow, PyTorch framework, and GPU drivers. The experimental environment integrates four core modules: Experimental documentation is rendered in Markdown format, supporting table of contents navigation, code block highlighting, and formula rendering (using MathJax), with real-time synchronization of experimental steps; the code editor uses Monaco Editor, supporting syntax highlighting, auto-completion, code formatting, error messages, and customizable themes and shortcuts; the runtime terminal is implemented using Xterm.js, supporting multi-terminal window switching, real-time output of program execution results and error information, and command-line operation; the underlying AI computing resources utilize an Alibaba Cloud GPU cluster, dynamically scheduled via Kubernetes, automatically allocating GPU resources of the corresponding specifications based on the computing power requirements of the experimental task (e.g., training a model requires 16GB of VRAM), with computing power usage displayed in real-time on the experimental environment interface to avoid resource waste.

[0026] For step S130, after the integrated experimental environment is loaded, the backend uses Cypher queries to extract the learning objective set and prerequisite knowledge subgraph corresponding to the specific experimental task from the Neo4j knowledge graph. First, the learning objective is matched according to the experimental task ID, and the query results are organized into a learning objective set. Each objective includes an objective name, a specific description, and an achievement standard (e.g., "Master Python function definition methods and be able to independently write functions with parameters"). The prerequisite knowledge subgraph is extracted by querying knowledge nodes and skill nodes that have a "prerequisite knowledge" relationship with the experimental task. The queried nodes and relationships are organized into a subgraph structure, which is returned to the frontend in JSON format for subsequent cognitive profile construction and learning path planning. Simultaneously, the prerequisite knowledge subgraph is displayed in the sidebar of the experimental environment, making it convenient for students to view the prerequisite content they need to master.

[0027] Students' historical interaction data is stored in a MongoDB database, containing structured and unstructured data such as past experiment scores, code submission records, error rectification status, learning time, and resource access records. First, all historical interaction data for a student is retrieved by student ID. Then, for each knowledge node in the preceding knowledge subgraph, a weighted average method is used to calculate the historical mastery score, with the following weighting: 60% accuracy rate in the experiment, 20% error rectification rate, 10% related resource learning time, and 10% classroom quiz score. Calculation example: A student achieved an 85% accuracy rate, a 90% error rectification rate, and scored 100 points for exceeding the average resource learning time in the "Python List Operations" knowledge node. Their classroom quiz score was 80 points. Therefore, the historical mastery score for this node is 85 × 0.6 + 90 × 0.2 + 100 × 0.1 + 80 × 0.1 = 87 points. By integrating the mastery scores of all prerequisite knowledge nodes and combining them with students' learning preferences (such as whether they prefer video learning or document learning) and learning speed, an initial cognitive profile of the student is constructed. The profile is stored in JSON format and includes the student ID, mastery of each knowledge node, learning preference tags, learning weaknesses, etc., to provide data support for subsequent personalized guidance.

[0028] For step S140, various interactive data are collected in real time through the front-end monitoring module and back-end log collection module of the integrated experimental environment throughout the entire process of students performing experimental tasks. The code operation sequence records the content and corresponding timestamp of each code input, modification, and save by listening to MonacoEditor's input, save, and delete events. The format is "{timestamp:1713888000000, operation type: input, content:def func(x):, position: line 5}". The program runtime log captures the stdout and stderr output of the Docker container on the backend, and structures the log content in the format of "timestamp-log level-log content", filtering invalid logs and retaining runtime information and error information related to the experimental task. The computing resource access sequence collects data such as CPU utilization, GPU utilization, memory usage, and network I / O every 100ms through the Kubernetes monitoring interface, and records the start time, end time, and peak resource consumption of resource access. The user interface interaction events record student actions such as clicking experimental documents, switching terminal windows, and viewing prompts by listening to frontend click, hover, and switch events. All collected data is sorted in ascending order by timestamp, converted into a structured event sequence in JSON format, and pushed to the backend in real time for storage and analysis to ensure data integrity and timeliness.

[0029] S150, based on structured event sequences and course knowledge graphs, performs root cause diagnosis on errors made by students during the execution of specific experimental tasks, and generates a set of root cause hypotheses. The specific steps include: The error events in the structured event sequence are matched with the predefined error pattern nodes in the course knowledge graph to obtain a set of matched error patterns. For each error pattern in the set of matched error patterns, a reverse search is performed along the causal relationship edges in the course knowledge graph until the knowledge node or skill node that is the root cause is located. The confidence of each root cause node is calculated to generate a set of root cause hypotheses.

[0030] Reference Figure 2 The steps of matching error events in a structured event sequence with predefined error pattern nodes in the course knowledge graph specifically include S210-S230: S210, extract the features of the error event, the features of which include at least the error type and error code context; S220, calculate the similarity between the error event features and the features of each error pattern node in the course knowledge graph; S230, if the similarity exceeds the preset matching threshold, it is determined that the error event and the error pattern node are successfully matched.

[0031] Specifically, for step S210, error events (events with log levels of ERROR and WARNING) in the program runtime log are filtered from the collected structured event sequence, and then feature extraction is performed on the error events. Error types are determined using a combination of regular expression matching and natural language classification, with a pre-defined error type library (such as syntax errors, logical errors, runtime errors, resource shortage errors, etc.). For example, "SyntaxError: invalidsyntax" is identified as a syntax error by regular expression matching, and "IndexError: list index out of range" is identified as an index out of range logical error by analysis. The error code context extracts the three lines of code before and after the error location (if the error occurs on line 5, then lines 2-8 are extracted), along with the specific location of the error (line number, column number), error description information, and the program's runtime state at the time of the error (such as variable values ​​and function call stack). In addition, auxiliary features such as error frequency and error duration can be extracted. For example, if a student makes the same syntax error three times consecutively within 10 minutes, this feature can be used for subsequent root cause analysis. All extracted features are organized into feature vectors, which are used for similarity matching with error pattern nodes in the course knowledge graph.

[0032] For step S220, the extracted error event features and the features of each error pattern node in the course knowledge graph are first converted into standardized feature vectors. The construction of the error event feature vector involves encoding the error type (e.g., syntax error is encoded as 1, logical error as 2), and using the TF-IDF algorithm to extract the TF-IDF values ​​of the Top-N (e.g., Top 20) keywords from the error code context as context features. Then, the error type encoding, normalized auxiliary features, and Top-N context features are concatenated to obtain a fixed-dimensional (e.g., 25-dimensional) feature vector. The construction method for the error pattern node feature vector is consistent with that of the error events. Each error pattern node has a pre-defined corresponding feature vector (e.g., the feature vector of the "list index out of bounds error" pattern node includes logical error encoding, index-related keywords, common error locations, etc.). Similarity calculation uses the cosine similarity algorithm, and the calculation formula is... Where A is the feature vector of the error event and B is the feature vector of the error mode node. The angle between two vectors is denoted by a cosine value. The closer the cosine value is to 1, the higher the similarity.

[0033] For step S230, a preset similarity matching threshold is set, dynamically adjusted according to the difficulty level of the experimental task. For example, the threshold is set to 0.8 for basic difficulty, 0.85 for medium difficulty, and 0.9 for advanced difficulty. After calculating the similarity between the error event and each error pattern node, the similarity is compared with the preset threshold. If the similarity exceeds the threshold, it is considered a successful match, and the error pattern node is added to the matched error pattern set. If multiple error pattern nodes have similarities exceeding the threshold, they are sorted in descending order of similarity, and the top three nodes are taken as the core matching nodes. Subsequent root cause analysis will focus on these three nodes. For example, if an error event has similarities of 0.98, 0.92, and 0.88 with "list index out of bounds error," "list length judgment error," and "variable undefined error," and the preset threshold is 0.85, then the matched error pattern set consists of the first two nodes, and subsequent root cause search will be based on these two nodes.

[0034] Reference Figure 3 For each error pattern in the set of matched error patterns, the steps of performing a reverse search along the causal relationship edges in the course knowledge graph specifically include S310-S340: S310, starting from the matching error pattern node, performs a reverse breadth-first search along the causal and dependency type relationship edges in the course knowledge graph; S320: Stop searching when the search depth reaches the preset maximum depth or when the search reaches a knowledge node or skill node that no longer has a prerequisite relationship. S330 marks all knowledge nodes or skill nodes traversed during the search process as candidate root cause nodes; S340, calculate the confidence score of each candidate root cause node based on the path length from the candidate root cause node to the starting error mode node and the weight of the relationship on the path.

[0035] Specifically, for step S310, a backward breadth-first search (BFS) algorithm is used. Starting from a matched error pattern node, the search proceeds along the causal and dependency relationship edges in the course knowledge graph. These causal and dependency relationship edges mainly include three types: "cause," "need," and "dependency." This means searching backward from the error pattern node for the preceding knowledge or skill nodes that might lead to the error. The search process is implemented using a queue. First, all matched error pattern nodes are enqueued. Then, nodes are sequentially removed from the queue, and all backward relationship edges (i.e., relationship edges pointing to the node) of that node are traversed. The node at the other end of each relationship edge is added to the queue, and the search path (starting node → intermediate node → candidate root cause node) is recorded. For example, starting from the "list index out of bounds error" node, the search backward along its "cause" relationship edge finds the "list length judgment error" node. Then, starting from this node, the search backward along its "dependency" relationship edge finds the "list length acquisition method" node. This process is continued sequentially to ensure that no possible root cause nodes are missed.

[0036] For step S320, a maximum search depth is preset, determined based on the knowledge graph level corresponding to the experimental task, generally set to 3-5 levels. This avoids excessive depth leading to too many root cause nodes and difficulty in location, while also preventing shallow searches from missing key root cause nodes. During the reverse BFS search, the current search depth is recorded in real time. When the search depth reaches the preset maximum depth, the search immediately stops. If a knowledge node or skill node with no predecessor relationship is encountered during the search (i.e., the node has no reverse relationship edge and is a basic node in the knowledge graph, such as "Python basic syntax"), the search for that branch stops, and the search continues to other branches. For example, with a preset maximum search depth of 3, starting the search from the "list index out of bounds error" node, the first level finds "list length judgment error", the second level finds "list length acquisition method", and the third level finds "Python built-in function len() usage". At this point, the search depth reaches the maximum value, and the search stops. If a branch searches for the "Python basic syntax" node, and this node has no predecessor relationship, the search for that branch stops.

[0037] For step S330, after the reverse BFS search stops, all knowledge nodes and skill nodes traversed during the search are collected, duplicate nodes are removed, and these nodes are uniformly marked as candidate root cause nodes. During the marking process, a search path label is added to each candidate root cause node, recording the search path from the starting error mode node to itself, as well as the node's position in the path, to facilitate subsequent calculation of confidence scores. For example, if the nodes traversed during the search are "list length judgment error", "list length acquisition method", "Python built-in function len() usage", and "list definition method", after removing duplicate nodes, all four nodes are marked as candidate root cause nodes, each node corresponding to a search path, such as "list index out of bounds error → list length judgment error → list length acquisition method → ​​Python built-in function len() usage". At the same time, the candidate root cause nodes are associated with nodes in the course knowledge graph to obtain detailed information for each node (such as node description, associated resources, etc.).

[0038] For step S340, the confidence score measures the probability that each candidate root cause node will cause an error event. The calculation considers two core factors: the path length from the candidate root cause node to the initial error pattern node, and the weights of the relation edges along the path. A shorter path length indicates a stronger association between the node and the error pattern node, resulting in higher confidence. Higher weights of relation edges along the path indicate a greater impact of the node on the error, also resulting in higher confidence. For example, the preset relation edge weights are 0.5-1.0, with the highest weight for the "cause" relation being 1.0, the "dependency" relation being 0.8, and the "need" relation being 0.5. The specific calculation formula is: Confidence Score = (1 / Total number of relation edges along the path) × Σ (Weight of each relation edge along the path), where Σ (Weight of each relation edge along the path) is the sum of the weights of all relation edges along the search path corresponding to that node.

[0039] All candidate root cause nodes are sorted in descending order of confidence score. A pre-set confidence threshold (usually 0.7) is used to filter out candidate root cause nodes whose confidence scores exceed the threshold, which are then selected as the final root cause nodes. If the number of nodes with confidence scores exceeding the threshold is too large (more than 5), the top 3 nodes with the highest confidence scores are selected as the core root cause nodes to ensure the targeted nature of root cause localization. Then, a root cause hypothesis set is generated based on these root cause nodes. Each root cause hypothesis includes the root cause node name, a root cause description (e.g., "Students did not master the method of obtaining list length, resulting in an inability to correctly determine the index range, leading to a list index out-of-bounds error"), and corresponding improvement suggestions (e.g., "Learn how to use the Python built-in function len() and practice calculating list length"). The root cause hypothesis set is presented in a structured document format.

[0040] For step S160, for each root cause node in the root cause hypothesis set, the mastery score of that node is lowered. The reduction amount is determined by the confidence score; the higher the confidence score, the greater the reduction (e.g., a node with a confidence score of 1.0 is lowered by 15 points, and a node with a confidence score of 0.9 is lowered by 12 points). Then, the student's successful behavior records (such as correctly completed experimental steps, correctly written code snippets, successfully solved small problems, etc.) are analyzed to identify the knowledge nodes or skill nodes that the student has mastered, and the mastery scores of these nodes are increased (by 5-10 points). At the same time, the student's learning weakness labels are updated, adding the knowledge weakness corresponding to the root cause node to the profile and deleting the weakness labels corresponding to the mastered nodes. For example, if a student's initial cognitive profile shows a mastery score of 80 for "methods for obtaining list length," this node is considered the root cause node (confidence level 0.9), and the score is reduced by 12 points to 68 points. If a student successfully completes the "list traversal" operation, the mastery score for the "list traversal" node is increased (from 75 points to 85 points). The updated real-time cognitive profile is more in line with the student's current learning status.

[0041] Reference Figure 4 In S170, the steps for generating the optimal learning path sequence for students based on real-time cognitive profiles, learning objectives for specific experimental tasks, and course knowledge graphs specifically include S410-S430: S410 uses the learning objectives of a specific experimental task as the endpoint and the knowledge nodes that students have mastered as the starting point. It combines the mastery scores of each knowledge node in the student's real-time cognitive profile, the inherent difficulty value of the knowledge node in the course knowledge graph, and the estimated learning time to construct a weighted path search graph. S420, In the path search graph, search for the path with the minimum cumulative cost from the starting point to the ending point, and generate the optimal learning path sequence; S430 transforms each knowledge node in the optimal learning path sequence into specific guidance instructions, and generates corresponding non-intrusive code hints and learning resource recommendations based on the student's current code context in the integrated experimental environment, which are then displayed in real time in the user interface of the integrated experimental environment.

[0042] Reference Figure 5 In S410, the steps for constructing a weighted path search graph specifically include S510-S530: S510, Determine the node set of the path search graph, which includes all knowledge nodes, skill nodes, and teaching resource nodes related to a specific experimental task; S520, based on the "prerequisite knowledge" relationship in the course knowledge graph, determines the directed edges between nodes in the node set, with the direction indicating the learning order; S530 calculates the weight for each directed edge. The formula for calculating the weight is: weight = w1 × inherent difficulty value of the target node × [(100 - student's mastery of the source node) / 100] + w2 × (estimated learning time of the target node / total estimated time of a single experiment), where w1 and w2 are preset weight coefficients used to balance cognitive difficulty and time cost.

[0043] Specifically, for step S510, the node set of the path search graph is determined by taking the learning objective of the specific experimental task as the endpoint (i.e., all nodes in the learning objective set extracted in S130) and the knowledge nodes with a mastery score ≥80 in the student's real-time cognitive profile as the starting point (considered as content that the student has mastered). The node set not only includes all knowledge nodes and skill nodes related to the specific experimental task, but also corresponding teaching resource nodes (such as videos, documents, exercises, etc.). Teaching resource nodes are connected to knowledge nodes and skill nodes through "associated resource" relationship edges. The construction of the node set must ensure completeness and relevance, removing nodes that are irrelevant to the current experimental task, while supplementing all possible auxiliary nodes (such as skill nodes related to the use of experimental tools). For example, if the learning objective of the experimental task is "mastering Python function writing and calling", and the starting nodes are "Python variable definition" and "Python data types" (both with a mastery score ≥80), the node set will include knowledge nodes and skill nodes such as "Python function definition", "Python function parameters", "Python function calling", and "function debugging skills", as well as teaching resource nodes such as "Python function teaching videos" and "function writing exercises".

[0044] For step S520, based on the existing "prerequisite knowledge" relationships in the course knowledge graph, the directed edges between all nodes in the node set are identified. The direction of the directed edges indicates the learning order, i.e., from a prerequisite knowledge node to a subsequent knowledge node, meaning that students must master the prerequisite knowledge nodes before learning the subsequent knowledge nodes. First, the "prerequisite knowledge" relationships of all nodes in the node set are extracted using Cypher queries. Then, the retrieved relationships are organized into directed edges, constructing the topology of the path search graph to ensure the rationality of the directed edges and avoid circular dependencies (e.g., A is a prerequisite for B, and B is a prerequisite for A). For example, if the prerequisite knowledge for "Python function parameters" in the node set is "Python variable definition," then a directed edge is constructed from "Python variable definition" to "Python function parameters"; if the prerequisite knowledge for "Python function calls" is "Python function definition" and "Python function parameters," then a directed edge is constructed from these two nodes to "Python function calls," clarifying the learning order.

[0045] For step S530, a weight is calculated for each directed edge in the path search graph. The weight is used to measure the cost of the learning path (cognitive difficulty + time cost). The lower the weight, the more suitable the path is for the student's current learning state. For any directed edge in the path search graph, the starting node of the directed edge is defined as the source node (i.e., the preceding knowledge node), and the ending node is defined as the target node (i.e., the subsequent knowledge node). The weight calculation formula is: Weight = w1 × inherent difficulty value of the target node × [(100 - student's mastery of the source node) / 100] + w2 × (estimated learning time of the target node / total estimated time of a single experiment), where w1 and w2 are preset weight coefficients used to balance cognitive difficulty and time cost, and are dynamically adjusted according to the type of experimental task. Generally, w1 = 0.6 and w2 = 0.4 (cognitive difficulty takes precedence over time cost); the inherent difficulty value of the target node is preset by expert users and graded from 1 to 10 (1 point is the easiest and 10 points is the most difficult). For example, the difficulty value of "Python function definition" is 4, and the difficulty value of "function debugging skills" is 7; the student's mastery of the source node is taken from the real-time cognitive profile and is represented by 0-100 points; the estimated time of learning the target node is the average time required to complete the learning of the node, in minutes, which is obtained by the teaching data center based on historical learning data (e.g., the estimated time of "Python function definition" is 20 minutes).

[0046] After construction, for step S420, Dijkstra's algorithm is used to search for the minimum cumulative cost path from the start point to the end point in the path search graph. The cumulative cost is the sum of the weights of all directed edges on the path, and the path with the minimum cumulative cost is the optimal learning path sequence. First, the cumulative cost of the start node is initialized to 0, and the cumulative costs of other nodes are set to infinity. Then, a priority queue (min-heap) is used to store the nodes to be processed. Each time, the node with the minimum cumulative cost is retrieved, and all outgoing edges (directed edges pointing to subsequent nodes) of that node are traversed. The cumulative cost of the subsequent nodes is calculated as (current node's cumulative cost + edge weight). If the calculated cumulative cost is less than the current cumulative cost of the node, the cumulative cost of the node is updated, and the predecessor node of the path is recorded. This process is repeated until the end point node is reached. Then, by backtracking through the predecessor node, the minimum cumulative cost path from the start point to the end point is obtained, which is the optimal learning path sequence. Example: Assume the total estimated duration of a single experiment is 100 minutes, the start point is 'Python variable definition' (mastery level 90), and the end point is 'Python function call'. Path 1: Python variable definition → Python function parameters (Difficulty 3, Duration 15) → Python function call (Difficulty 6, Duration 30), edge 1 weight 0.24, edge 2 weight 1.20, cumulative cost 1.44; Path 2: Python variable definition → Python function definition (Difficulty 4, Duration 20) → Python function call (Difficulty 6, Duration 30), edge 1 weight 0.32, edge 2 weight 1.56, cumulative cost 1.88. Since 1.44 < 1.88, Path 1 is the optimal learning path sequence, and subsequent guidance instructions will be generated based on this sequence.

[0047] For step S430, each knowledge node and skill node in the optimal learning path sequence is transformed into specific and actionable guidance instructions. These instructions are written in the format of "step-operational requirements-acceptance criteria," tailored to the student's current experimental progress and code context. For example, the "Python function parameters" node in the path sequence is transformed into the following guidance instructions: "Step 1: Learn how to define positional and keyword arguments for Python functions; Step 2: In the current code, add two positional arguments and one keyword argument to the defined function; Step 3: Run the code to ensure that the parameters are passed correctly and there are no syntax errors." Meanwhile, based on the student's current code context in the integrated experimental environment (obtained in real time through the editor), corresponding non-intrusive code prompts are generated. The prompts do not directly provide the complete code, but rather guide students to think independently. For example, if a student has not added function parameters, the prompt will say, "Parameters can be added within the parentheses of the function definition, in the format of def function_name(parameter1, parameter2=default_value):". Learning resources are recommended based on node type. Knowledge nodes recommend corresponding teaching videos and documents, while skill nodes recommend corresponding practice questions and case code. The recommended content is displayed in the right-hand prompt bar of the experimental environment, which students can click to view independently without interfering with normal experimental operations, ensuring personalized and non-intrusive guidance.

[0048] In S180, the specific steps for updating the mastery level of corresponding knowledge nodes in students' long-term cognitive profiles based on their performance include: Based on the student's completion of the guidance instructions, the learning effectiveness score is calculated. A dynamic weighted fusion algorithm is used to merge the learning effectiveness score with the original long-term mastery score of the corresponding knowledge node. The dynamic weighted fusion algorithm is: New mastery = (Original mastery × Credibility parameter + Learning effectiveness score) / (Creativity parameter + 1), where the credibility parameter increases with the number of times the corresponding knowledge node is learned.

[0049] Specifically, for step S180, after students complete each guided instruction, the learning effectiveness score is calculated through a combination of automatic evaluation module and manual evaluation in the integrated experimental environment. The score ranges from 0 to 100 points and is scored in three dimensions: code correctness (60 points), operational efficiency (20 points), and error rectification rate (20 points). Code correctness is automatically evaluated through preset test cases. For example, if a guided instruction requires writing a function with parameters, the test case checks whether the output result meets expectations by calling the function. Complete correctness earns 60 points, partial correctness deducts points proportionally, and complete error earns 0 points. Operational efficiency is calculated based on the ratio of the time taken to complete the guided instruction to the estimated time. Time ≤ estimated time earns 20 points, 2 points are deducted for every 10% exceeding the estimated time, and 0 points are earned for exceeding 50%. Error rectification rate is calculated based on the number of errors made by the student during the completion of the instruction and the rectification status. No errors earn 20 points, errors made but all rectified correctly earn 15-18 points, and errors made but not rectified or rectified incorrectly earn 0-14 points.

[0050] A dynamic weighted fusion algorithm is employed to integrate the current learning outcome score with the existing long-term mastery score of the corresponding knowledge node. This updates the mastery score of the corresponding knowledge node in the student's long-term cognitive profile, ensuring that the mastery score accurately reflects the student's long-term learning performance. The dynamic weighted fusion algorithm is as follows: New Mastery = (Original Mastery × Credibility Parameter + Learning Outcome Score) / (Creativity Parameter + 1). The credibility parameter balances the weights of the original mastery score and the current learning outcome. This parameter increases with the number of times the corresponding knowledge node has been learned. The initial value is 1, and the credibility parameter increases by 0.5 for each additional learning session (completion of a related guidance instruction or experiment). For example, if a student has completed two related learning sessions for a certain knowledge node (i.e., the update is performed on the third learning session), the credibility parameter has increased by 2 sessions, and the credibility parameter = 1 + 0.5 × 2 = 2. The updated long-term cognitive profile is stored in a MongoDB database. At the same time, the entire process data (structured event sequences, learning performance scores, cognitive profile update records, error messages, etc.) is stored in the teaching data center in JSON format. MySQL is used to store structured data and MongoDB is used to store unstructured data, providing data support for subsequent knowledge graph updates and teaching optimization.

[0051] Reference Figure 6 The intelligent teaching experiment method also includes: a system knowledge evolution process based on the accumulation of teaching data. This system knowledge evolution process is monitored and driven by the administrator user through the console, specifically including S610-S660: S610 collects learning performance data of all students at each knowledge node from the teaching data center and calculates the average performance of the group. S620: If the average effectiveness of a certain knowledge node is consistently lower than the preset effectiveness threshold, the corresponding knowledge node will be marked as a teaching difficulty and a review prompt will be generated in the console. S630 analyzes frequently occurring "error-repair" event pairs. If a stable and unrecorded new pattern is formed, a candidate error pattern node is generated in the console. S640 continuously collects new content from preset external information sources, obtains candidate knowledge triples through information extraction technology, and calculates the corresponding confidence level; S650 pushes teaching difficulty prompts, candidate error pattern nodes, and candidate knowledge triples with confidence scores to expert users for review via the console. S660 will officially merge and update the new knowledge nodes, new relationship edges, and associated teaching resources that expert users confirm as valid in the console into the main knowledge graph and course resource library.

[0052] Specifically, for step S610, learning performance data for all students at each knowledge node is collected from the teaching data center. The collection time range can be flexibly set (e.g., the past month, the past semester). The collection method involves querying the learning performance table in the MySQL database using SQL statements. The retrieved data is grouped by knowledge node ID, and the average performance for each knowledge node is calculated as the arithmetic mean of all students' learning performance scores for that node, rounded to one decimal place. Simultaneously, the standard deviation of performance for each knowledge node is calculated to analyze the dispersion of student scores. A larger standard deviation indicates greater differences in students' mastery of that node. Example: For the "Python Function Definitions" knowledge node, there is learning performance data for 50 students with a total score of 4250. The average performance is 4250 / 50 = 85.0 points, and the standard deviation is 6.2, indicating that students' overall mastery of this node is relatively good, with moderate differences. After collection and calculation, the results are compiled into a table and pushed to the administrator console.

[0053] For step S620, a preset effectiveness threshold is set, determined based on the difficulty level of the knowledge node. The threshold is set to 75 points for basic difficulty nodes, 80 points for medium difficulty nodes, and 85 points for advanced difficulty nodes. This threshold can be manually adjusted by the administrator in the console. The system monitors the average effectiveness of each knowledge node in real time. If the average effectiveness of a knowledge node falls below the preset threshold for three consecutive statistical periods (e.g., three consecutive weeks), the knowledge node is marked as a teaching difficulty, and a review prompt is generated in the administrator console. The prompt includes the knowledge node name, the average effectiveness for the three consecutive periods, the effectiveness threshold, and the dispersion of student mastery, along with preliminary review suggestions (e.g., "It is recommended to review whether the teaching resources for this node are sufficient and whether the experimental task design is reasonable"). Administrators can click on the prompt to view detailed data (e.g., the distribution of student errors for this node and a list of students with low scores) to facilitate targeted optimization of teaching content. For example, the average group performance for the "Python Decorators" knowledge node (medium difficulty, threshold 80 points) was 78.2 points, 77.5 points, and 76.8 points for three consecutive weeks, respectively, all below the threshold. It was marked as a teaching difficulty and the console generated a corresponding review prompt.

[0054] For step S630, "error-repair" event pairs are collected from all students in the teaching data center. Each event pair contains an error event (error type, error content) and a corresponding repair event (repair method, repaired code). Association rule mining algorithms (such as the Apriori algorithm) are used to analyze frequently occurring "error-repair" event pairs. Support thresholds (e.g., 5%) and confidence thresholds (e.g., 80%) are set. Support represents the frequency of the event pair among all "error-repair" event pairs, and confidence represents the success rate of using the repair method after the error occurs. If the support and confidence of an "error-repair" event pair both exceed the preset thresholds, and the corresponding error pattern is not included in the course knowledge graph's error pattern library, a candidate error pattern node is generated in the administrator console. The candidate error pattern node contains information such as error type, error characteristics, repair method, and frequency of occurrence. For example, the event pair "decorator syntax missing @ symbol error - add @ symbol repair" has a support of 6%, a confidence of 85%, and is not included in the library; a corresponding candidate error pattern node is generated for expert review.

[0055] For step S640, external information sources are pre-defined, including authoritative technical blogs in the computer field (such as CSDN and Juejin), open-source communities (such as GitHub), university open course materials, and industry standard documents. New content from these sources is collected regularly via web crawlers (such as the Scrapy framework), with a collection frequency of once per day to ensure the timeliness of the content. The collected new content undergoes information extraction using Natural Language Processing (NLP) technology, employing the BERT model for entity recognition and relation extraction to obtain candidate knowledge triples (subject, relation, object). Then, a multi-dimensional weighted scoring algorithm is used to calculate confidence levels. The calculation rules combine factors such as the authority of the content source (e.g., 0.8 for university course materials, 0.4 for ordinary blogs), content relevance (degree of association with the course knowledge graph), and sentence completeness. The confidence level ranges from 0 to 1.0. Triples with a confidence level ≥ 0.8 are considered high-confidence candidates and pushed to subsequent review stages.

[0056] For step S650, the teaching difficulty prompts marked in S620, the candidate error pattern nodes generated in S630, and the candidate knowledge triples with confidence scores extracted in S640 are compiled into a unified review checklist and pushed to expert users (such as course instructors and domain technical experts) for review via the administrator console. The review checklist is presented in the format of "Type-Content-Related Data." For example, teaching difficulty prompts include node name, average effectiveness, and dispersion; candidate error pattern nodes include error characteristics, repair methods, and frequency of occurrence; and candidate knowledge triples include triple content, confidence score, and source link. Expert users can mark each review item (valid / invalid) in the console. For valid items, supplementary explanations can be added (such as modifying the feature description of the error pattern node), and for invalid items, the reasons can be explained (such as the candidate knowledge triples being irrelevant to the course). The review process is recorded in real time, and the review results are synchronously stored in the teaching data center for easy subsequent traceability and statistics.

[0057] For step S660, after expert users complete their review, administrator users confirm the review results in the console, marking the experts as valid new knowledge nodes, new relationship edges, and associated teaching resources, and officially merging and updating them into the main knowledge graph and course resource library. New knowledge nodes (such as match-case statements) are added with attributes such as node ID, name, description, and difficulty value according to the node specifications of the course knowledge graph and inserted into the Neo4j graph database; new relationship edges (such as Python 3.12 → Add → match-case statements) are added between corresponding nodes according to the relationship type specifications; associated teaching resources (such as teaching videos and documents for match-case statements) are uploaded to Alibaba Cloud OSS object storage, updating the resource list in the course resource library and associating them with the corresponding knowledge nodes. After the update is complete, the system automatically synchronizes and updates the course details page of the course portal, the knowledge graph visualization content, and related resources of the integrated experimental environment to ensure that all students can access the latest course content; simultaneously, an update log is generated, recording the update content, update time, reviewers, and other information, and stored in the teaching data center for easy subsequent management and traceability.

[0058] Based on the above method embodiments, the second embodiment of this application discloses an intelligent teaching experiment platform. The intelligent teaching experiment platform of this application embodiment can implement any of the above-described intelligent teaching experiment methods, and the specific working process of each module in the intelligent teaching experiment platform can be referred to the corresponding process in the above method embodiments.

[0059] For ease of understanding, an example is as follows: An intelligent teaching experiment platform includes: The course portal module is used to present a course list and course details page to student users. The course details page integrates and displays the course catalog, course knowledge graph and course video explanations. The environment invocation module is used to respond to students' selection of specific experimental tasks on the course details page, and invoke an integrated experimental environment that matches the specific experimental task. The integrated experimental environment integrates experimental document guidance, code editor, running terminal and underlying AI computing power resources. The profile initialization module is used in an integrated experimental environment to extract the set of learning objectives and the prior knowledge subgraph corresponding to a specific experimental task based on the course knowledge graph, and to calculate the student's historical mastery score of each knowledge node in the prior knowledge subgraph based on the student's historical interaction data, thereby constructing the student's initial cognitive profile. The data acquisition and processing module is used to collect students' code operation sequences, program runtime logs, computing resource access sequences, and user interface interaction events in real time through the integrated experimental environment when students perform specific experimental tasks according to the experimental documentation. These data are then converted into a structured event sequence ordered by time. The root cause diagnosis module is used to diagnose the root causes of errors made by students during the execution of specific experimental tasks based on structured event sequences and course knowledge graphs, and generate a set of root cause hypotheses. The real-time cognitive profile update module is used to update the student's initial cognitive profile based on the root cause hypothesis set and the student's successful behavior records during the execution of a specific experimental task, so as to obtain the student's real-time cognitive profile. The path planning and guidance module is used to generate the optimal learning path sequence for students based on real-time cognitive profiles, learning objectives of specific experimental tasks, and course knowledge graphs. Based on the optimal learning path sequence and the current context of students in the integrated experimental environment, it generates and presents corresponding non-intrusive guidance instructions. The long-term cognitive profile update and data accumulation module is used to update the mastery of corresponding knowledge nodes in the student's long-term cognitive profile based on the student's completion of the guidance instructions, and to accumulate the entire process data into the teaching data center.

[0060] The third embodiment of this application provides a computer-readable storage medium storing a computer program that can be loaded by a processor and executed as an intelligent teaching experiment method.

[0061] The computer-readable storage medium can be any tangible medium that contains or stores a program that can be used by or in connection with an instruction execution system, apparatus, or device; the program code contained on the computer-readable medium can be transmitted using any suitable medium, including but not limited to wireless, wire, optical fiber, RF, etc., or any suitable combination thereof.

[0062] The above are all preferred embodiments of this application and are not intended to limit the scope of protection of this application. Any feature disclosed in this specification (including the abstract and drawings) may be replaced by other equivalent or similar features unless specifically stated otherwise. That is, unless specifically stated otherwise, each feature is only one example of a series of equivalent or similar features.

Claims

1. An intelligent teaching experiment method, characterized in that, include: The course portal presents a course list and a course details page to student users. The course details page integrates and displays the course catalog, course knowledge graph, and course video explanations. In response to a student's selection of a specific experimental task on the course details page, an integrated experimental environment matching the specific experimental task is invoked. The integrated experimental environment integrates experimental documentation guidance, a code editor, a running terminal, and underlying AI computing resources. In the integrated experimental environment, the learning objective set and the prior knowledge subgraph corresponding to the specific experimental task are extracted according to the course knowledge graph, and the historical mastery score of the student for each knowledge node in the prior knowledge subgraph is calculated based on the student's historical interaction data to construct the student's initial cognitive profile. When the student performs the specific experimental task in the integrated experimental environment according to the experimental document, the integrated experimental environment collects the student's code operation sequence, program runtime log, computing resource access sequence and user interface interaction events in real time, and converts them into a structured event sequence ordered by time. Based on the structured event sequence and the course knowledge graph, root cause diagnosis is performed on the errors made by the students during the execution of the specific experimental task, and a set of root cause hypotheses is generated. Based on the root cause hypothesis set and the student's successful behavior records during the execution of the specific experimental task, the student's initial cognitive profile is updated to obtain the student's real-time cognitive profile. Based on the real-time cognitive profile, the learning objectives of the specific experimental task, and the course knowledge graph, an optimal learning path sequence is generated for the student. Based on the optimal learning path sequence and the student's current context in the integrated experimental environment, corresponding non-intrusive guidance instructions are generated and presented. After the student completes the guidance instructions, the mastery of the corresponding knowledge node in the student's long-term cognitive profile is updated according to the student's completion effect, and the entire process data is stored in the teaching data center. The steps for generating the optimal learning path sequence for the student based on the real-time cognitive profile, the learning objectives of the specific experimental task, and the course knowledge graph specifically include: Using the learning objective of the specific experimental task as the endpoint and the knowledge nodes already mastered by the student as the starting point, a weighted path search graph is constructed by combining the mastery scores of each knowledge node in the student's real-time cognitive profile, the inherent difficulty value of the knowledge node in the course knowledge graph, and the estimated learning time. In the path search graph, the path with the minimum cumulative cost from the starting point to the ending point is searched to generate the optimal learning path sequence; Each knowledge node in the optimal learning path sequence is transformed into a specific guidance instruction, and based on the student's current code context in the integrated experimental environment, corresponding non-intrusive code prompts and learning resource recommendations are generated and presented in real time in the user interface of the integrated experimental environment. The specific steps for constructing a weighted path search graph include: Determine the node set of the path search graph, the node set containing all knowledge nodes, skill nodes and teaching resource nodes related to the specific experimental task; Based on the "prerequisite knowledge" relationship in the course knowledge graph, the directed edges between nodes in the node set are determined, and the direction indicates the learning order. Calculate the weight for each directed edge. The weight is calculated as follows: weight = w1 × inherent difficulty value of the target node × [(100 - student's mastery of the source node) / 100] + w2 × (estimated learning time of the target node / total estimated time of a single experiment), where w1 and w2 are preset weight coefficients used to balance cognitive difficulty and time cost. The steps for updating the mastery level of corresponding knowledge nodes in the student's long-term cognitive profile based on the student's performance specifically include: Calculate the learning effectiveness score based on the student's completion of the guidance instructions; A dynamic weighted fusion algorithm is adopted to merge the current learning effectiveness score with the original long-term mastery score of the corresponding knowledge node. The dynamic weighted fusion algorithm is: New mastery = (Original mastery × Credibility parameter + Learning effectiveness score) / (Creativity parameter + 1), where the credibility parameter increases with the increase of the number of times the corresponding knowledge node is learned.

2. The intelligent teaching experiment method according to claim 1, characterized in that, Based on the structured event sequence and the course knowledge graph, the steps for performing root cause diagnosis on errors made by students during the execution of the specific experimental task and generating a set of root cause hypotheses specifically include: The error events in the structured event sequence are matched with the predefined error pattern nodes in the course knowledge graph to obtain a set of matched error patterns; For each error pattern in the set of matched error patterns, a reverse search is performed along the causal relationship edges in the course knowledge graph until the knowledge node or skill node that is the root cause is located, and the confidence of each root cause node is calculated to generate the set of root cause hypotheses.

3. The intelligent teaching experiment method according to claim 2, characterized in that, The specific steps of matching error events in the structured event sequence with predefined error pattern nodes in the course knowledge graph include: Extract the features of the error event, wherein the features include at least the error type and the error code context; Calculate the similarity between the error event features and the features of each error pattern node in the course knowledge graph; If the similarity exceeds a preset matching threshold, it is determined that the error event and the error pattern node are successfully matched.

4. The intelligent teaching experiment method according to claim 3, characterized in that, For each error pattern in the set of matched error patterns, the step of performing a reverse search along the causal relationship edges in the course knowledge graph specifically includes: Starting from the matched error pattern node, perform a reverse breadth-first search along the causal and dependency relationship edges in the course knowledge graph; The search will stop when the search depth reaches the preset maximum depth or when the search reaches a knowledge node or skill node that no longer has a prerequisite relationship. Mark all knowledge nodes or skill nodes encountered during the search process as candidate root cause nodes; Calculate the confidence score for each candidate root cause node based on the path length from the candidate root cause node to the starting error mode node and the weight of the relationships on the path.

5. The intelligent teaching experiment method according to claim 1, characterized in that, The intelligent teaching experiment method also includes: a system knowledge evolution process based on the accumulation of teaching data, which is monitored and driven by the administrator user through the console. The learning performance data of all students at each knowledge node is collected from the teaching data center, and the average performance of the group is calculated. If the average effectiveness of a certain knowledge node is consistently lower than the preset effectiveness threshold, the corresponding knowledge node will be marked as a teaching difficulty and a review prompt will be generated in the console. Analyze frequently occurring "error-fix" event pairs. If a stable and unrecorded new pattern is formed, generate a candidate error pattern node in the console. Continuously collect new content from preset external information sources, obtain candidate knowledge triples through information extraction technology, and calculate the corresponding confidence scores; The teaching difficulty prompts, candidate error pattern nodes, and candidate knowledge triples with confidence scores are pushed to expert users for review on the console. New knowledge nodes, new relationship edges, and associated teaching resources that expert users have confirmed as valid in the console will be officially merged and updated into the main knowledge graph and course resource library.

6. An intelligent teaching experimental platform, characterized in that, The intelligent teaching experiment method described in any one of claims 1 to 5 includes: a course portal module, used to present a course list and a course details page to student users, wherein the course details page integrates and displays a course catalog, a course knowledge graph, and course video explanations; The environment invocation module is used to respond to the student's selection of a specific experimental task on the course details page, and invoke an integrated experimental environment that matches the specific experimental task. The integrated experimental environment integrates experimental document guidance, code editor, running terminal and underlying AI computing power resources. The profile initialization module is used in the integrated experimental environment to extract the learning target set and the prior knowledge subgraph corresponding to the specific experimental task according to the course knowledge graph, and to calculate the student's historical mastery score of each knowledge node in the prior knowledge subgraph according to the student's historical interaction data, so as to construct the student's initial cognitive profile. The data acquisition and processing module is used to collect the student's code operation sequence, program runtime log, computing resource access sequence and user interface interaction events in real time through the integrated experimental environment when the student performs the specific experimental task in the integrated experimental environment according to the experimental document instructions, and convert them into a structured event sequence ordered by time. The root cause diagnosis module is used to perform root cause diagnosis on the errors made by the students during the execution of the specific experimental task based on the structured event sequence and the course knowledge graph, and generate a set of root cause hypotheses. The real-time cognitive profile update module is used to update the student's initial cognitive profile based on the root cause hypothesis set and the student's successful behavior records during the execution of the specific experimental task, so as to obtain the student's real-time cognitive profile. The path planning and guidance module is used to generate an optimal learning path sequence for the student based on the real-time cognitive profile, the learning objectives of the specific experimental task, and the course knowledge graph, and to generate and present corresponding non-intrusive guidance instructions based on the optimal learning path sequence and the student's current context in the integrated experimental environment. The long-term profile update and data accumulation module is used to update the mastery of the corresponding knowledge nodes in the student's long-term cognitive profile according to the student's completion effect after the student completes the guidance instructions, and to accumulate the entire process data into the teaching data center.

7. A computer-readable storage medium, characterized in that, The computer program is stored and can be loaded by a processor and executed as described in any one of claims 1 to 5.

Images