Courseware content generation method and device, electronic equipment and computer medium

Abstract

The present disclosure provides a courseware content generation method and device, electronic equipment and computer medium. The specific scheme is: receiving a personalized courseware generation request; determining at least one target dimension node in the courseware state tree based on the personalized courseware generation request; according to the node type, selecting the corresponding heterogeneous pipeline from the heterogeneous pipeline set, generating and sending the corresponding processing task to the mutually isolated heterogeneous pipeline, and collecting the current load data returned by each heterogeneous pipeline; for each target dimension node, independently hash calculating the current load data of the target dimension node to generate the corresponding current node hash value; based on the current node hash value of each target dimension node and the node hash value of the corresponding dimension node in the courseware state tree which has not changed, calculating the current root hash value, and updating the courseware state tree; issuing the current load data, the current node hash value and the current root hash value of at least one target dimension node to the client.

Description

Technical Field

[0001] This disclosure belongs to the field of artificial intelligence technology, specifically involving technical fields such as educational technology and large-scale language models, and in particular a method and apparatus for generating courseware content, electronic devices, and computer-readable storage media. Background Technology

[0002] With the popularization of Large Language Model (LLM) technology, a large number of AI-based automatic courseware and lesson plan generation systems have emerged in the education field. Currently, the basic workflow of commonly used AI (Artificial Intelligence) courseware generation technology solutions is as follows: receiving natural language prompts from the user, triggering the large language model to process them, and finally outputting a continuous long text stream (such as Markdown format) or directly converting it into a presentation file with a fixed layout (such as XML or PPTX format).

[0003] However, from the perspective of underlying software engineering and distributed system architecture, this existing technology, which heavily relies on the generation of "black-box text streams," may have the following technical defects in actual large-scale commercial applications: the data structure is "unstructured and flat," making fine-grained state management and local addressing impossible; the content data layer and the display rendering layer are "strongly coupled," blocking the dynamic injection of interactive interface components; "black-box text generation" blocks the deterministic verification path, easily leading to the illusion of uncontrollable algorithms; and there is a great waste of computing power and network resources, making it unable to support high-concurrency dynamic reorganization with extremely low latency. Summary of the Invention

[0004] This disclosure provides a method and apparatus for generating courseware content, an electronic device, and a computer-readable storage medium.

[0005] According to the first aspect, a method for generating courseware content is provided, applied to a server. The server is pre-configured with a heterogeneous pipeline set. The method includes: receiving a personalized courseware generation request sent by a client, the personalized courseware generation request including a target entity identifier and a target user feature identifier; based on the target user feature identifier and the target entity identifier, identifying at least one target dimension node in the pre-stored courseware state tree that has missed the cache or whose parameters have changed; selecting a corresponding heterogeneous pipeline from the heterogeneous pipeline set according to the node type of the at least one target dimension node; generating a corresponding processing task based on the target entity identifier and / or the target user feature identifier; distributing the processing tasks in parallel to mutually isolated heterogeneous pipelines; and collecting data from each pipeline. The heterogeneous pipeline returns current payload data, and the heterogeneous pipeline set includes at least a non-large language model query pipeline and a large language model inference pipeline. For each target dimension node, the current payload data of the target dimension node is independently hashed using a cryptographic hash function to generate the corresponding current node hash value. Based on the current node hash value of each target dimension node and the node hash value of the corresponding dimension node that has not changed in the courseware state tree, the current root hash value is calculated and the courseware state tree is updated. At least one target dimension node's current payload data, current node hash value, and current root hash value are sent to the client so that the client can update the local courseware content based on the current payload data, current node hash value, and current root hash value.

[0006] According to the second aspect, a courseware content generation device is provided, applied to a server. The server is pre-configured with a heterogeneous pipeline set. The device includes: a receiving unit configured to receive a personalized courseware generation request sent by a client, the personalized courseware generation request including a target entity identifier and a target user feature identifier; a determining unit configured to determine, based on the target user feature identifier and the target entity identifier, at least one target dimension node in a pre-stored courseware state tree that has not been cached or whose parameters have changed; and an allocation unit configured to select a corresponding heterogeneous pipeline from the heterogeneous pipeline set according to the node type of the at least one target dimension node, generate a corresponding processing task based on the target entity identifier and / or the target user feature identifier, distribute the processing task in parallel to mutually isolated heterogeneous pipelines, and collect the data from each heterogeneous pipeline. The pipeline returns current payload data, and the heterogeneous pipeline set includes at least a non-large language model query pipeline and a large language model inference pipeline; a hash calculation unit is configured to independently hash the current payload data of each target dimension node using a cryptographic hash function to generate the corresponding current node hash value; a hash calculation unit is configured to calculate the current root hash value based on the current node hash value of each target dimension node and the node hash value of the corresponding dimension node that has not changed in the courseware state tree, and update the courseware state tree; a distribution unit is configured to distribute at least one target dimension node's current payload data, current node hash value, and current root hash value to the client, so that the client can update the local courseware content based on the current payload data, current node hash value, and current root hash value.

[0007] According to a third aspect, an electronic device is provided, comprising: at least one processor; and a memory communicatively connected to the at least one processor, wherein the memory stores instructions executable by the at least one processor, the instructions being executed by the at least one processor to enable the at least one processor to perform a method as described in any implementation of the first aspect.

[0008] According to a fourth aspect, a computer-readable storage medium is provided having computer instructions stored thereon for causing a computer to perform the method as described in any implementation of the first aspect.

[0009] The courseware content generation method and apparatus provided in the embodiments of this disclosure first receive a personalized courseware generation request sent by a client, the personalized courseware generation request including a target entity identifier and a target user feature identifier; second, based on the target user feature identifier and the target entity identifier, determine at least one target dimension node in the pre-stored courseware state tree that has missed the cache or whose parameters have changed; third, according to the node type of the at least one target dimension node, select a corresponding heterogeneous pipeline from a set of heterogeneous pipelines, generate a corresponding processing task based on the target entity identifier and / or the target user feature identifier, distribute the processing task in parallel to mutually isolated heterogeneous pipelines, and collect the current load count returned by each heterogeneous pipeline. According to the data, the heterogeneous pipeline set includes at least a non-large language model query pipeline and a large language model inference pipeline. Then, for each target dimension node, a cryptographic hash function is used to independently hash the current payload data of that target dimension node, generating a corresponding current node hash value. Next, based on the current node hash values ​​of each target dimension node and the node hash values ​​of the corresponding dimension nodes that have not changed in the courseware state tree, the current root hash value is calculated, and the courseware state tree is updated. Finally, at least one target dimension node's current payload data, current node hash value, and current root hash value are sent to the client, enabling the client to update its local courseware content based on the current payload data, current node hash value, and current root hash value. Therefore, by decoupling the courseware generation task and selectively routing it to non-large language model query pipelines (such as underlying databases or vector retrieval) and large language model inference pipelines, the overall response latency is compressed to the time consumption of the slowest single branch by using ultra-fast queries from the underlying database to replace time-consuming full-text inference from the large model. The traditional flat and unstructured courseware text stream is reconstructed into a tree-like data container with fine-grained state management capabilities. This transformation of the underlying data structure enables the application logic layer at the backend of the system to perform precise programmable addressing and state tracking of local content (i.e., independent dimension nodes) of the courseware, realizing object-level CRUD operations. The current payload data and hash value of the target dimension node are sent to the client so that the client can compare the hash value and update the local courseware content. The underlying layer introduces the idea of ​​differential synchronization based on hash trees. Therefore, when facing personalized requests from a large number of users with different characteristics, the system does not need to repeatedly call the underlying model for full-text reconstruction. The hash values ​​of data nodes that have not changed remain unchanged and are directly hit from the cache. This not only avoids the repeated calculation of the same macro knowledge target, but also significantly reduces the expensive computational power consumption.

[0010] It should be understood that the description in this section is not intended to identify key or essential features of the embodiments of this disclosure, nor is it intended to limit the scope of this disclosure. Other features of this disclosure will become readily apparent from the following description. Attached Figure Description

[0011] The accompanying drawings are provided to better understand this solution and do not constitute a limitation of this disclosure. Wherein:

[0012] Figure 1 This is a flowchart of an embodiment of the method for generating content based on this open courseware;

[0013] Figure 2 These are the five different node types of dimension nodes disclosed herein;

[0014] Figure 3 This is a schematic diagram of a structure in this publication that distributes personalized courseware generation requests to five completely different and independent heterogeneous pipelines;

[0015] Figure 4 This is a schematic diagram of the structure of one embodiment of the courseware content generation device according to the present disclosure;

[0016] Figure 5 This is a block diagram of an electronic device used to implement the courseware content generation method of the embodiments of this disclosure. Detailed Implementation

[0017] Unless otherwise expressly stated, throughout the specification and claims, the term "comprising" or its variations such as "including" or "comprises" shall be understood to include the stated elements or components without excluding other elements or other components.

[0018] Existing AI courseware generation technologies heavily rely on black-box text streams, resulting in four significant technical shortcomings in large-scale commercial deployment:

[0019] First, the data structure is "unstructured and flat," making fine-grained state management and local addressing impossible. Specifically, the output of large models in existing technologies is essentially a continuous string sequence. Because its data structure is flat and unstructured, the application logic layer at the backend of the system cannot perform programmable independent addressing of local content in the courseware. For example, the system cannot accurately locate and extract the independent entity "teaching strategies in the courseware" for cross-comparison with other databases. If a part needs to be modified, the system usually has to re-send the entire long text into the large model for generation, making object-level CRUD operations impossible.

[0020] Secondly, the strong coupling between the content data layer and the display rendering layer prevents the dynamic injection of interactive interface components. Specifically, existing generation systems directly output terminal code for display (such as HTML strings or fixed-layout slides), resulting in a tight binding between content data and user interface display code. When courseware needs to present complex interactive teaching tools (such as rendering a draggable 3D model or mounting a code sandbox with a runtime environment), the method of simply relying on text stream generation becomes completely ineffective. Because the front end cannot parse explicit component mounting instructions and initialization parameters from long texts, current AI courseware can only display static images and text and cannot drive the dynamic virtual DOM (Document Object Model) tree in modern web applications.

[0021] Third, "black-box text generation" blocks the deterministic verification path, easily leading to the illusion of uncontrollable algorithms. Specifically, large models are essentially probabilistic autoregressive generative models, inevitably subject to knowledge illusions. Because existing systems output continuous, unformatted natural language, they cannot insert robust mathematical calculation rules for verification at the gateway or middleware level. For example, they cannot perform precise, machine-readable comparisons of the generated text with the national curriculum standard knowledge graph database. This means that existing systems cannot completely prevent compliance risks such as exceeding curriculum standards or knowledge point mismatches from the underlying code logic.

[0022] Fourth, there is a significant waste of computing and network resources, making it impossible to support high-concurrency dynamic reconfiguration with extremely low latency. Specifically, when dealing with multiple users within the same group with different backgrounds, to achieve personalized courseware distribution, the existing system must send multiple complete generation requests with different contexts to the large model. This coarse-grained, serial generation method leads to a huge waste of computing resources. In reality, the historical background and macro-value of the core knowledge points in the courseware of different users are usually completely consistent, with differences only in local strategies. Because the existing technology does not decouple and manage the hash state at the underlying level of the courseware dimension, the system must repeatedly reason about a large amount of the same content, making the real-time personalized courseware generation under large-scale, high-concurrency conditions face extremely high economic costs and computational latency.

[0023] To overcome the problems in the prior art, this disclosure proposes a method for generating courseware content. Figure 1 A flowchart 100 is shown as an embodiment of the courseware content generation method according to this disclosure, the courseware content generation method including the following steps:

[0024] Step 101: Receive the personalized courseware generation request sent by the client.

[0025] In this embodiment, the personalized courseware generation request includes the target entity identifier and the target user feature identifier.

[0026] In this embodiment, the server can receive personalized courseware generation requests sent by the client through a pre-configured courseware generation interface. The requests can be sent using communication methods such as HTTP / HTTPS, WebSocket, or RPC, and in JSON, XML, or Protocol formats. The request is carried in structured data formats such as Buffers. Upon receiving the request, the server first verifies the request source, user login status, interface signature, timestamp, and permission information. After successful verification, the server parses the request message and extracts the target entity identifier and target user feature identifier. The target entity identifier uniquely indicates the teaching object, knowledge point, course, chapter, question set, or teaching resource entity corresponding to the courseware to be generated. The target user feature identifier indicates the learning characteristic profile, ability level, learning preferences, historical learning behavior, or cognitive state of the target learning user or user group. Furthermore, the server can perform legality verification and standardization processing on the target entity identifier and target user feature identifier, such as verifying whether the identifier is empty, exists in a preset database, or has an access relationship with the current client. After successful verification, the server generates the corresponding courseware generation task and writes the task into the task queue or the courseware generation service processing flow. This allows the server to subsequently obtain the corresponding teaching content based on the target entity identifier and determine the content difficulty, presentation format, knowledge point coverage, and exercise configuration of the courseware based on the target user feature identifier, thereby generating personalized courseware that matches the target user.

[0027] Step 102: Based on the target user feature identifier and the target entity identifier, identify at least one target dimension node in the pre-stored courseware state tree that has not been cached or whose parameters have changed.

[0028] In this embodiment, after obtaining the target user feature identifier and the target entity identifier, the server uses these identifiers as an index to query the pre-stored courseware state tree. The courseware state tree includes multiple courseware dimension nodes, each storing a node identifier, dimension parameters, cache key values, and cache status information. The server traverses each courseware dimension node sequentially according to the hierarchical relationship of the courseware state tree and generates a current verification key based on the target user feature identifier, the target entity identifier, and the dimension parameters corresponding to the current courseware dimension node. The server then matches the current verification key with the cache key values ​​already stored in that courseware dimension node. If no cache key is found... If cached data corresponding to the current verification key is found, the courseware dimension node is determined to be a cache-missing node. If cached data is found, but the current dimension parameter is inconsistent with the historical dimension parameter recorded when the courseware dimension node was last cached, or at least one of the parameter version number, update timestamp, or hash value has changed, the courseware dimension node is determined to be a node with changed parameters. Then, the courseware dimension nodes that missed the cache and / or the courseware dimension nodes with changed parameters are determined as at least one target dimension node so that subsequent courseware content updates, state recalculations, or cache reconstruction are performed only on the target dimension nodes.

[0029] Conversely, if cached data corresponding to the current verification key is found, and the current dimension parameters are consistent with historical parameters and the hash value has not changed, then the courseware dimension node is determined to be a cache-hit non-changed node. For non-changed nodes, the system directly short-circuits the corresponding heterogeneous pipeline call and directly reads its historical payload data and historical node hash value from memory or edge cache. This fine-grained local cache hit mechanism avoids repeated calculations of the same knowledge background or the same courseware target under massive concurrent requests, greatly saving underlying computing power and large model inference resources.

[0030] Step 103: Based on the node type of at least one target dimension node, select the corresponding heterogeneous pipeline from the heterogeneous pipeline set, generate the corresponding processing task based on the target entity identifier and / or target user feature identifier, distribute the processing task in parallel to the mutually isolated heterogeneous pipelines, and collect the current load data returned by each heterogeneous pipeline.

[0031] In this embodiment, the heterogeneous pipeline set includes at least a non-large language model query pipeline and a large language model inference pipeline. The non-large language model query pipeline can be a thread pool allocated for database queries, and the large language model inference pipeline can be a separate GPU (Graphics Processing Unit) memory pool allocated for large language model inference. The non-large language model query pipeline and the large language model inference pipeline are physically / logically isolated, thereby preventing long-tail inference from blocking high-speed queries.

[0032] In this embodiment, a heterogeneous pipeline refers to an independent data processing flow in the server-side used to process different types of courseware dimension nodes. Different pipelines can use different calculation methods, such as SQL queries, vector retrieval, graph database queries, collaborative filtering recommendations, or large language model inference.

[0033] In this embodiment, the parallel distribution of processing tasks to isolated heterogeneous pipelines and the collection of current load data returned by each heterogeneous pipeline include: distributing processing tasks to corresponding heterogeneous microservice coroutines for execution via an asynchronous task orchestration engine; setting a synchronization barrier during the aggregation phase to wait for all triggered heterogeneous microservice coroutines to return processing results; and assembling the current load data returned by each heterogeneous pipeline into a complete updated state tree node through a deep copy merging operation after the synchronization barrier is removed. Here, the asynchronous task orchestration engine refers to a concurrency control module running at the operating system or middleware level. It manages multiple I / O-intensive or computationally intensive tasks non-blockingly. In this invention, this engine enables the system to dispatch tasks to multiple heterogeneous pipelines (such as database queries and large model inference) without waiting for the previous task to complete before initiating the next task, thereby compressing the overall system response latency from the sum of the times of each pipeline to the time of the slowest single pipeline. Here, the synchronization barrier refers to a synchronization mechanism in multi-threaded / multi-coroutine concurrent programming. In this invention, since the generation time for the five dimensions of courseware data varies (e.g., database queries take only a few milliseconds, while large model inference takes hundreds of milliseconds), a synchronization barrier is used to forcibly suspend the main thread during the "aggregation" phase until all triggered microservice coroutines have returned results. This ensures the absolute integrity of the courseware state tree sent to the client in terms of data structure, avoiding null pointer exceptions caused by asynchronous return time differences.

[0034] In this embodiment, deep copy merging refers to recursively copying the values ​​of an object and all its child objects in memory, rather than simply copying memory address references (shallow copy). In this invention, since the courseware state tree adopts a complex hierarchical structure, using deep copy merging to merge the payload data returned by each pipeline can prevent memory reference pollution between different microservice coroutines, ensuring that the generated JSON Schema or Protobuf objects are completely independent and thread-safe before serialization and distribution.

[0035] In this embodiment, a mapping relationship between node types and heterogeneous pipelines can be pre-established. After the scheduler obtains at least one target dimension node, it parses the node type, input parameters, and dependency context of each target dimension node, and determines the corresponding heterogeneous pipeline based on the mapping relationship. For example, for structured data retrieval, rule matching, or index query nodes, they are distributed to the non-large language model query pipeline for execution; for semantic generation, complex reasoning, or natural language understanding nodes, they are distributed to the large language model inference pipeline for execution. The scheduler encapsulates the processing tasks corresponding to each target dimension node into independent task requests and sends them in parallel to isolated heterogeneous pipelines through thread pools, coroutines, message queues, or remote procedure calls. Different pipelines can run in different processes, containers, service instances, or compute resource pools to avoid resource contention or state interference between query tasks and model inference tasks. After receiving a task request, each heterogeneous pipeline generates current payload data based on its own processing logic. For example, the query pipeline returns retrieval results, matching results, or feature data, while the large language model inference pipeline returns inference text, semantic tags, or intermediate inference results. The pipeline then returns the current payload data to the scheduler along with the task identifier. The scheduler collects, verifies, and merges the current payload data returned by each pipeline according to the task identifier. If there are timeouts, anomalies, or empty results, the scheduler performs retry, degradation, or placeholder processing to obtain parallel processing results corresponding to at least one target dimension node.

[0036] Step 104: For each target dimension node, use a cryptographic hash function to perform independent hash calculation on the current payload data of the target dimension node to generate the corresponding current node hash value.

[0037] In this embodiment, after obtaining the current payload data corresponding to each target dimension node, the target dimension nodes can be processed one by one according to the preset node identifier order. For any target dimension node, its current payload data is first normalized and encoded, such as unifying the field order, character encoding, time format, numerical precision, and null value representation, to ensure that the same payload data has a consistent byte sequence on different devices or in different execution environments. Then, a preset cryptographic hash function is called to perform independent hash calculation on the byte sequence. The cryptographic hash function can be SHA-256, SHA-3, SM3, or other hash algorithms that meet collision resistance and one-wayness requirements, thereby obtaining a fixed-length digest value, which is then used as the current node hash value of the target dimension node. The hash calculations between each target dimension node are independent of each other. The current node hash value of a target dimension node is determined only by the current payload data of the target dimension node itself. This allows for the rapid location of changed target dimension nodes during subsequent verification, comparison, or tracing processes, improving the accuracy and processing efficiency of data integrity verification.

[0038] Step 105: Calculate the current root hash value based on the current node hash value of each target dimension node and the node hash value of the corresponding dimension node that has not changed in the courseware state tree, and update the courseware state tree.

[0039] In this embodiment, after obtaining the current node hash value of each target dimension node, the root hash value is recalculated from bottom to top according to the preset hierarchical relationship and node sorting rules of the courseware state tree. Specifically, for target dimension nodes that have changed, their original node hash value in the courseware state tree is replaced with the corresponding current node hash value. For other dimension nodes that have not changed, their node hash values ​​stored in the courseware state tree are directly read and reused. Subsequently, for each parent node, the node hash values ​​of its subordinate child nodes are concatenated in a preset order, and the current node hash value of the parent node is calculated using a preset hash algorithm. This process is iterated layer by layer until the current root hash value is calculated. After obtaining the current root hash value, the hash values ​​of each level of nodes on the affected path in the courseware state tree are updated to the current node hash value obtained in this calculation, and the current root hash value is saved as the unique state identifier of the current state of the courseware. Thus, incremental updates to the courseware state tree are achieved without recalculating the hash values ​​of all dimension nodes.

[0040] Step 106: Send the current load data, current node hash value, and current root hash value of at least one target dimension node to the client so that the client can update the local courseware content based on the current load data, current node hash value, and current root hash value.

[0041] In this embodiment, to enable the client to update local courseware content based on current payload data, current node hash value, and current root hash value, the process includes: the client receiving the current root hash value and comparing it with the locally cached initial root hash value; in response to a discrepancy between the current root hash value and the initial root hash value, the client traversing the local courseware state tree and using the current node hash value to locate the target dimension node with the inconsistent hash; and only for the target dimension node, replacing the local payload data with the issued current payload data to complete a local differential update. For example, the client receives the current root hash value, finds that it is inconsistent with the initial root hash value, and upon traversal, discovers that the current node hash value of the "courseware strategy node" has changed. Therefore, it only replaces the JSON data of this one node, triggering a partial repaint of the React / Vue virtual DOM.

[0042] In this embodiment, local differential update refers to a technique where the client does not overwrite the entire local data, but only replaces the data blocks that have changed. In this disclosure, combined with cryptographic hash comparison, the system can accurately locate which specific dimension of the payload has changed out of the five dimensions. The client only requests and replaces the payload of the failed node, which greatly reduces the network I / O overhead of personalized courseware distribution under large-scale concurrency and the computational overhead of redrawing the front-end DOM tree.

[0043] In this embodiment, after receiving the current payload data, the client traverses the dimension nodes in the courseware state tree; determines the target component reference in the preset component registry based on the component mounting instruction field; when the component code corresponding to the target component reference is not loaded, the corresponding component code block is loaded asynchronously; the structured payload field and initialization parameters are injected into the target component, and the instantiated target component is mounted to the client rendering tree.

[0044] In this embodiment, after determining at least one target dimension node to be updated by the client, the server reads the current payload data corresponding to each target dimension node, the current node hash value calculated from the current payload data and / or its child node hash values, and the current root hash value of the courseware dimension hash tree from a pre-constructed courseware dimension hash tree. The server then encapsulates this data into an update verification package and sends it to the client. Upon receiving the update verification package, the client first recalculates the corresponding node hash value based on the current payload data of the target dimension node according to a pre-agreed hash algorithm, and performs a consistency comparison with the current node hash value sent by the server. Then, it combines... The path information of the target dimension node in the courseware dimension hash tree and the hash values ​​of related sibling nodes are used to calculate the local verification root hash value level by level upwards. The local verification root hash value is then compared with the current root hash value issued by the server. If both the current node hash value and the current root hash value are consistent, it is determined that the current payload data has not been tampered with during transmission and storage, and the current payload data is written to the corresponding dimension node position in the local courseware to complete the incremental update of the courseware. If either verification is inconsistent, the update is rejected and a verification failure message can be reported to the server, thereby ensuring the integrity and reliability of the updated local courseware data on the client.

[0045] The courseware content generation method provided in this disclosure first receives a personalized courseware generation request sent by a client, the personalized courseware generation request including a target entity identifier and a target user feature identifier; second, based on the target user feature identifier and the target entity identifier, at least one target dimension node is identified as a courseware dimension node in the pre-stored courseware state tree that has not hit the cache or whose parameters have changed; third, according to the node type of the at least one target dimension node, a corresponding heterogeneous pipeline is selected from a set of heterogeneous pipelines, a corresponding processing task is generated based on the target entity identifier and / or the target user feature identifier, and the processing tasks are distributed in parallel to mutually isolated heterogeneous pipelines, and the current load data returned by each heterogeneous pipeline is collected. The heterogeneous pipeline set includes at least a non-large language model query pipeline and a large language model inference pipeline. Then, for each target dimension node, a cryptographic hash function is used to independently hash the current payload data of that target dimension node, generating a corresponding current node hash value. Next, based on the current node hash values ​​of each target dimension node and the node hash values ​​of the corresponding dimension nodes that have not changed in the courseware state tree, the current root hash value is calculated, and the courseware state tree is updated. Finally, at least one target dimension node's current payload data, current node hash value, and current root hash value are sent to the client, enabling the client to update its local courseware content based on the current payload data, current node hash value, and current root hash value. Therefore, by decoupling the courseware generation task and selectively routing it to non-large language model query pipelines (such as underlying databases or vector retrieval) and large language model inference pipelines, the overall response latency is compressed to the time consumption of the slowest single branch by using ultra-fast queries from the underlying database to replace time-consuming full-text inference from the large model. The traditional flat and unstructured courseware text stream is reconstructed into a tree-like data container with fine-grained state management capabilities. This transformation of the underlying data structure enables the application logic layer at the backend of the system to perform precise programmable addressing and state tracking of local content (i.e., independent dimension nodes) of the courseware, realizing object-level CRUD operations. The current payload data and hash value of the target dimension node are sent to the client so that the client can compare the hash value and update the local courseware content. The underlying layer introduces the idea of ​​differential synchronization based on hash trees. Therefore, when facing personalized requests from a large number of users with different characteristics, the system does not need to repeatedly call the underlying model for full-text reconstruction. The hash values ​​of data nodes that have not changed remain unchanged and are directly hit from the cache. This not only avoids the repeated calculation of the same macro knowledge target, but also significantly reduces the expensive computational power consumption.

[0046] In some optional implementations of this disclosure, the above-mentioned courseware state tree is constructed through the following steps: based on the initial courseware generation request, node payload data of nodes in different dimensions are obtained in parallel through multiple isolated heterogeneous pipelines. The initial courseware generation request includes: user feature identifier; the node payload data is assembled into an initial state tree according to a preset tree data model; the node hash value of each dimension node is calculated using a cryptographic hash function, and the root hash value of the initial state tree is generated by concatenating the hash values ​​of each node bit by bit, thus obtaining the courseware state tree.

[0047] In this optional implementation, upon receiving the initial courseware generation request carrying user feature identifiers, the system first determines multiple dimension nodes required for courseware generation based on these user feature identifiers, such as user profile nodes, teaching objective nodes, knowledge point structure nodes, material resource nodes, interactive question type nodes, and layout strategy nodes. The system then distributes the processing tasks corresponding to each dimension node to multiple isolated heterogeneous pipelines for parallel execution. These different pipelines can employ different data sources, model services, rule engines, or content generation components to avoid state coupling and mutual contamination between different dimension data processing processes. After each pipeline completes its processing, it outputs the corresponding dimension node. The node payload data is then loaded onto the corresponding parent and child node positions according to a preset tree data model, forming an initial state tree containing hierarchical and semantic relationships. Further, for each dimension node in the initial state tree, the node identifier, node type, node payload data, and optional version information of the node are normalized and serialized, and the node hash value of the dimension node is calculated using a cryptographic hash function. Then, the hash values ​​of each node are concatenated bit by bit according to the preset node order and hashed again to obtain the root hash value of the initial state tree, thereby generating a courseware state tree with content integrity verification capability and state traceability capability.

[0048] In some optional implementations of this disclosure, the tree-like data model includes: a root node, representing the courseware entity; multiple logically isolated dimension nodes, which are child nodes of the root node, including: courseware target node, courseware value node, courseware strategy node, courseware history node, and courseware interaction node; wherein, the data structure of each dimension node includes a component mounting instruction field, a structured payload field, and an external resource pointer field; before sending at least one target dimension node's current payload data, current node hash value, and current root hash value to the client, the method further includes: obtaining the user permission level corresponding to the target user feature identifier; configuring a data access control list for each field in the target dimension node at the gateway layer based on the user permission level; in response to the target dimension node including an external resource pointer field and the user permission level being lower than a preset threshold, blocking the sending of the external resource pointer field, and only sending the component mounting instruction field and the structured payload field; after blocking the external resource pointer field, re-normalizing and encoding based on the field set sent to the client and calculating the current node hash value.

[0049] like Figure 2 As shown, the tree-structured data model branches out from the root node into multiple dimensional nodes and metadata. These dimensional nodes include: courseware target nodes, courseware value nodes, courseware strategy nodes, courseware history nodes, and courseware interaction nodes. The metadata includes: data identifiers and the root hash value. Courseware target nodes include: action enumeration values, entity identifiers, etc. Courseware value nodes include: entity identifiers, nearest neighbor strategies, etc. Courseware strategy nodes include: entity identifiers, interface attributes, etc. Courseware history nodes include: node data, edge topology relationships, etc. Courseware interaction nodes include: state machines, event control information, etc.

[0050] In this optional implementation, the courseware state tree is stored in memory or a persistent database using a hierarchical topology of a directed acyclic graph (DAG). Component mounting instruction fields, structured payload fields, and external resource pointer fields are strictly isolated based on a predefined strongly typed communication protocol specification to prevent the injection of unstructured redundant fields. The strongly typed communication protocol specification refers to a set of rules (e.g., Protocol Buffers 3 or strict JSONSchema) that strictly validate the data type (e.g., integer, floating-point, enumeration, string of a specific length) of data fields during data serialization and deserialization. This specification will directly throw a parsing exception and discard the data at the gateway layer, physically preventing unstructured dirty data from damaging the front-end rendering engine. It should be noted that the DAG is logically expanded into a tree view based on the courseware entity root node and multiple dimension child nodes, used for performing node hash calculations and differential synchronization.

[0051] In some optional implementations of this disclosure, before performing independent hash calculations on the current payload data of each target dimension node using a cryptographic hash function to generate the corresponding current node hash value, the method further includes: in response to the target dimension node belonging to a courseware target node or a courseware interaction node, extracting the core action verbs from the current payload data and converting the core action verbs into word embedding vectors; calculating the cosine similarity between the word embedding vectors and the standard verb vectors in the preset course standard knowledge graph database; if the cosine similarity is less than a preset gating threshold, intercepting the current payload data and triggering a system degradation strategy.

[0052] In this optional implementation, the system degradation strategy is triggered by: discarding the current payload data output by the large language model inference pipeline; extracting the default standard payload data associated with the target entity identifier from the curriculum standard knowledge graph database; and using the default standard payload data as the current payload data of the target dimension node to block the algorithmic illusion of generated content.

[0053] In this optional implementation, before performing independent hash calculation on the current payload data of the target dimension node, the system first performs semantic gating verification on the current payload data: specifically, it performs word segmentation, part-of-speech tagging, and / or dependency parsing on the current payload data to identify the core action verbs used to represent learning behavior, evaluation behavior, or teaching task behavior, and maps these core action verbs to corresponding word embedding vectors through a pre-trained language model or a preset word embedding model; subsequently, it reads the set of standard verb vectors corresponding to the corresponding subject, grade level, ability dimension, or evaluation dimension from the preset curriculum standard knowledge graph database, and calculates the cosine similarity between the word embedding vectors and each standard verb vector. The system calculates the semantic matching result by taking the maximum similarity or weighted similarity. When the semantic matching result is less than the preset threshold, it determines that the behavioral description in the current payload data does not match the requirements of the curriculum standard or that there is an abnormal risk. The system then intercepts the current payload data, preventing it from entering the subsequent hash generation and node on-chain / solidification process, and triggers a system degradation strategy, such as transferring it to manual review, adopting conservative evaluation rules, recording anomaly logs, or reverting to the basic data processing process. When the semantic matching result is not less than the threshold, it determines that the current payload data passes the semantic consistency check, and continues to use a cryptographic hash function to perform independent hash calculation on the current payload data to generate the corresponding current node hash value.

[0054] In some optional implementations of this disclosure, the node type of the at least one target dimension node includes: courseware target, courseware value, courseware strategy, courseware history, and courseware interaction; based on the node type of the at least one target dimension node, a corresponding heterogeneous pipeline is selected from the heterogeneous pipeline set, a corresponding processing task is generated based on the target entity identifier and / or target user feature identifier, and the processing task is distributed in parallel to mutually isolated heterogeneous pipelines, including: in response to the target dimension node being any one of courseware target, courseware value, or courseware history, selecting from the heterogeneous pipeline set... The corresponding non-large language model query pipeline is selected, and the processing tasks including target entity identifiers are distributed to the non-large language model query pipeline. In response to the node type of the target dimension node being courseware strategy, the corresponding non-large language model query pipeline is selected from the heterogeneous pipeline set, and the processing tasks including target user feature identifiers are distributed to the non-large language model query pipeline. In response to the node type of the target dimension node being courseware interaction, the large language model inference pipeline is selected from the heterogeneous pipeline set, and the processing tasks including target user feature identifiers are distributed to the large language model inference pipeline.

[0055] like Figure 3 As shown, after the personalized courseware generation request is processed by the gateway, it enters the asynchronous task editor. The asynchronous task editor distributes different pipelines for the processing tasks corresponding to the personalized courseware generation request, such as... Figure 3 The pipeline consists of pipelines 1 through 5. Pipelines 1 through 4 are non-large language model query pipelines, used for target mapping, value retrieval, strategy engine configuration, and graph path extraction, respectively. Data from pipelines 1, 2, and 4 are stored sequentially in a relational database, a vector database, and a graph database. The strategy for pipeline 3 is obtained through a configuration center. Pipeline 5 is the large language model inference pipeline, used for generating interaction parameters. Pipeline 5 calls external interfaces through an LLM interface. Data from pipelines 1 through 5 is aggregated via a data aggregation bus to obtain the current payload data.

[0056] In this optional implementation, the system can pre-configure corresponding heterogeneous pipelines for different node types. After determining at least one target dimension node, the system first identifies the node type of each target dimension node. If the node type belongs to courseware target, courseware value, courseware strategy, or courseware history, it indicates that this type of node usually corresponds to structured or semi-structured deterministic data query requirements. The system selects a non-large language model query pipeline from the heterogeneous pipeline set and uses the target entity identifier and / or target user feature identifier as query input parameters to obtain the corresponding node data from a preset database, knowledge base, profile database, or historical behavior database. If the node type is courseware interaction, it indicates that this type of node involves natural language understanding, dialogue generation, interactive intent reasoning, or personalized feedback generation. The system selects a large language model reasoning pipeline from the heterogeneous pipeline set and generates the reasoning result of the courseware interaction dimension based on the target entity identifier, target user feature identifier, and relevant contextual information. This allows the system to call matching processing mechanisms for different types of target dimension nodes, improving the intelligence level of interactive content generation while ensuring the efficiency and accuracy of structured data processing.

[0057] In some optional implementations of this disclosure, the steps of the above-mentioned non-large language model query pipeline processing tasks include: responding to the node type being courseware target, executing a structured query statement based on the target entity identifier through the database query pipeline, and outputting standard action enumeration values; responding to the node type being courseware value, converting the target entity identifier into an entity vector through the vector query pipeline, performing a nearest neighbor search in a preset vector retrieval library, and outputting external resource pointers; responding to the node type being courseware strategy, converting the target user feature identifier into a user vector through the parameter query pipeline, and inputting the user vector into a preset collaborative filtering recommendation algorithm matrix, outputting component mounting instructions and initialization parameters; responding to the node type being courseware history, executing a graph database query statement based on the target entity identifier through the database query pipeline, and outputting historical evolution data including node and edge topological relationships.

[0058] In this optional implementation, when the node type of the target dimension node is determined to be any of the following: courseware target, courseware value, courseware strategy, or courseware history, the system does not call the large language model to generate the result. Instead, it selects the corresponding non-large language model query pipeline from the heterogeneous pipeline set for processing based on the node type: If the node type is courseware target or courseware history, a database query pipeline is selected, and the target entity identifier is input into the database query pipeline. The database query pipeline then generates the corresponding structured query statement or graph database query statement based on the target entity identifier to obtain the corresponding courseware target information or courseware history information from the relational database or graph database; if the node type is courseware value, a vector query pipeline is selected, and the target entity identifier is input into the vector query pipeline. The vector query pipeline vectorizes the target entity identifier to obtain an entity vector. Similarity retrieval or semantic matching is then performed based on this entity vector to obtain candidate information related to the courseware's value. If the node type is a courseware strategy, a parameter query pipeline is selected, and the target user feature identifier is input into it. This pipeline converts the target user feature identifier into a user vector, which is then input into a preset collaborative filtering recommendation algorithm matrix. Based on the matching result between the user vector and the collaborative filtering recommendation algorithm matrix, the interactive component identifier suitable for the target user and its corresponding initialization parameters are determined. This enables differentiated, lightweight, and interpretable data querying and parameter acquisition for different courseware dimension nodes.

[0059] In some optional implementations of this disclosure, the steps of the above-mentioned large language model inference pipeline processing task include: injecting a prompt word template with preset restrictions into the large language model based on the target user feature identifier in the processing task to limit the maximum number of lexical units generated by the model; and inputting logical parameters into the large language model so that the large language model outputs state machine controller instructions that conform to a preset structured field protocol as the current load data.

[0060] In this optional implementation, the state machine controller instructions are used to drive the client to perform page navigation, component rendering, or interaction state updates. When the system determines that the node type is "courseware interaction" when parsing the target dimension node, it can call the large language model inference pipeline from the heterogeneous pipeline set as the processing channel for the current payload data based on the pre-configured mapping relationship between node types and heterogeneous pipelines. Before performing inference, the large language model inference pipeline injects a prompt word template containing preset restrictions into the large language model used to calculate the current payload data. The prompt word template may include task roles, courseware interaction scenario descriptions, allowed content ranges, and prohibited output content types. The system incorporates constraints such as the maximum number of lexical units to control the generation boundaries and output length of the large language model. Subsequently, the large language model inference pipeline inputs logical parameters corresponding to the current courseware interaction node into the large language model. These logical parameters can include interaction event type, current courseware page identifier, user operation status, jump conditions, trigger conditions, feedback strategies, and subsequent status identifiers. This constrains the large language model to output state machine controller instructions according to a preset format, such as outputting instruction data that conforms to a preset field structure. This enables the state machine controller to execute courseware page jumps, interactive feedback, status updates, or process branch control based on the instructions, thereby achieving standardized and controllable inference processing of courseware interaction nodes.

[0061] To more clearly illustrate the execution process of this embodiment, a specific scenario is used as an example below. Assume that in the received personalized courseware generation request, the target entity is identified as "Newton's First Law," and the target user feature identifier represents "spatial visual preferences and basic level." The server-side master scheduler distributes the task in parallel to five heterogeneous pipelines: the database query pipeline executes an SQL query based on "Newton's First Law," outputting standard action enumeration values ​​(such as "interpretation" and "recognition"); the vector query pipeline performs a nearest neighbor search in the vector library, hitting pointers to external video resources such as "spacecraft gliding in space without power"; the parameter query pipeline, based on "spatial visual preferences," hits a preset collaborative filtering matrix, decides to attach the "2D frictionless physical slider simulation engine" component, and outputs initialization parameters with zero friction; the graph database query pipeline executes a Cypher query, outputting historical evolution topological data of "Aristotle -> Galileo -> Descartes -> Newton"; and the large language model inference pipeline, combined with the "basic level" feature, generates an interactive command for "whether one can walk on an absolutely smooth ice surface."

[0062] After each pipeline returns data, the server performs a deep copy and merge to generate the current state tree. It then calculates the hash value of the current node and the hash value of the current root for each of the five dimensions mentioned above, and finally sends the data to the client.

[0063] Further reference Figure 4 As an implementation of the methods shown in the above figures, this disclosure provides an embodiment of a courseware content generation device, which is similar to... Figure 1 Corresponding to the method embodiment shown, the device is executed by a dedicated computing node and can be specifically applied to various electronic devices.

[0064] like Figure 4 As shown, the courseware content generation device 400 provided in this embodiment includes: a receiving unit 401, a determining unit 402, an allocation unit 403, a hash calculation unit 404, a hash calculation unit 405, and a distribution unit 406. The receiving unit 401 can be configured to receive a personalized courseware generation request sent by a client, the personalized courseware generation request including a target entity identifier and a target user feature identifier. The determining unit 402 can be configured to, based on the target user feature identifier and the target entity identifier, determine at least one target dimension node as a courseware dimension node in a pre-stored courseware state tree that has not hit the cache or whose parameters have changed. The aforementioned allocation unit 403 can be configured to select a corresponding heterogeneous pipeline from a set of heterogeneous pipelines based on the node type of at least one target dimension node, generate a corresponding processing task based on the target entity identifier and / or target user feature identifier, distribute the processing task in parallel to mutually isolated heterogeneous pipelines, and collect the current payload data returned by each heterogeneous pipeline. The set of heterogeneous pipelines includes at least a non-large language model query pipeline and a large language model inference pipeline. The aforementioned hash calculation unit 404 can be configured to perform independent hash calculation on the current payload data of each target dimension node using a cryptographic hash function to generate a corresponding current node hash value. The aforementioned hash calculation unit 405 can be configured to calculate the current root hash value based on the current node hash value of each target dimension node and the node hash value of the corresponding dimension node that has not changed in the courseware state tree, and update the courseware state tree. The aforementioned distribution unit 406 can be configured to distribute at least one target dimension node's current load data, current node hash value, and current root hash value to the client, so that the client can update the local courseware content based on the current load data, current node hash value, and current root hash value.

[0065] In this embodiment, the specific processing and technical effects of the receiving unit 401, determining unit 402, allocating unit 403, hash calculation unit 404, hash calculation unit 405, and distributing unit 406 in the courseware content generation device 400 can be found in the following references. Figure 1 The relevant descriptions of steps 101, 102, 103, 104, 105, and 106 in the corresponding embodiments will not be repeated here.

[0066] In some embodiments of this disclosure, the courseware state tree is constructed by a construction unit (not shown in the figure). The construction unit is configured to: based on the initial courseware generation request, acquire node payload data of nodes of different dimensions in parallel through multiple isolated heterogeneous pipelines. The initial courseware generation request includes: user feature identifier; assemble the node payload data into an initial state tree according to a preset tree data model; calculate the node hash value of each dimension node using a cryptographic hash function, and concatenate the hash values ​​of each node bitwise to calculate the root hash value of the initial state tree, thereby obtaining the courseware state tree.

[0067] In some embodiments of this disclosure, the tree-like data model includes: a root node, representing the courseware entity; multiple logically isolated dimension nodes, which are child nodes of the root node, including: courseware target node, courseware value node, courseware strategy node, courseware history node, and courseware interaction node; wherein, the data structure of each dimension node includes a component mounting instruction field, a structured payload field, and an external resource pointer field; the courseware content generation device 400 further includes: a control unit (not shown in the figure), which is configured to: obtain the user permission level corresponding to the target user feature identifier; configure a data access control list for each field in the target dimension node at the gateway layer based on the user permission level; in response to the target dimension node including the external resource pointer field and the user permission level being lower than a preset threshold, block the distribution of the external resource pointer field and only distribute the component mounting instruction field and the structured payload field; after blocking the external resource pointer field, re-normalize and encode the field set distributed to the client and calculate the hash value of the current node.

[0068] In some embodiments of this disclosure, the courseware content generation device 400 further includes an interception unit (not shown in the figure), which is configured to: in response to the target dimension node belonging to the courseware target node or the courseware interaction node, extract the core action verbs in the current payload data and convert the core action verbs into word embedding vectors; calculate the cosine similarity between the word embedding vectors and the standard verb vectors in the preset curriculum standard knowledge graph database; if the cosine similarity is less than the preset gating threshold, intercept the current payload data and trigger the system degradation strategy.

[0069] In some embodiments of this disclosure, the node type of at least one target dimension node includes: courseware target, courseware value, courseware strategy, courseware history, and courseware interaction; the allocation unit 403 is configured to: in response to the node type of the target dimension node being any one of courseware target, courseware value, and courseware history, select the corresponding non-large language model query pipeline from the heterogeneous pipeline set, and distribute the processing task including the target entity identifier to the non-large language model query pipeline; in response to the node type of the target dimension node being courseware strategy, select the corresponding non-large language model query pipeline from the heterogeneous pipeline set, and distribute the processing task including the target user feature identifier to the non-large language model query pipeline; in response to the node type of the target dimension node being courseware interaction, select the large language model inference pipeline from the heterogeneous pipeline set, and distribute the processing task including the target user feature identifier to the large language model inference pipeline.

[0070] In some embodiments of this disclosure, each non-large language model query pipeline uses a first processing unit (not shown in the figure) to process the tasks. The first processing unit is configured to: respond to a node type of courseware target, execute a structured query statement based on the target entity identifier through a database query pipeline, and output standard action enumeration values; respond to a node type of courseware value, convert the target entity identifier into an entity vector through a vector query pipeline, perform a nearest neighbor search in a preset vector retrieval library, and output an external resource pointer; respond to a node type of courseware strategy, convert the target user feature identifier into a user vector through a parameter query pipeline, input the user vector into a preset collaborative filtering recommendation algorithm matrix, and output component mounting instructions and initialization parameters; respond to a node type of courseware history, execute a graph database query statement based on the target entity identifier through a database query pipeline, and output historical evolution data including node and edge topological relationships.

[0071] In some embodiments of this disclosure, the large language model inference pipeline employs a second processing unit (not shown in the figure) to process processing tasks. The second processing unit is configured to: inject a prompt word template with preset restrictions into the large language model based on the target user feature identifier in the processing task to limit the maximum number of lexical units generated by the model; and input logical parameters into the large language model so that the large language model outputs state machine controller instructions that conform to a preset structured field protocol as the current payload data.

[0072] The collection, storage, use, processing, transmission, provision, and disclosure of user personal information involved in the technical solution disclosed herein comply with the provisions of relevant laws and regulations and do not violate public order and good morals.

[0073] According to embodiments of this disclosure, this disclosure also provides an electronic device, a readable storage medium, and a computer program product.

[0074] Figure 5 A schematic block diagram of an example electronic device 500 that can be used to implement embodiments of the present disclosure is shown. The electronic device is intended to represent various forms of digital computers, such as laptop computers, desktop computers, workstations, personal digital assistants, servers, blade servers, mainframe computers, and other suitable computers. The electronic device may also represent various forms of mobile devices, such as personal digital processors, cellular phones, smartphones, wearable devices, and other similar computing devices. The components shown herein, their connections and relationships, and their patterns are merely examples and are not intended to limit the implementation of the present disclosure described and / or claimed herein.

[0075] like Figure 5 As shown, the electronic device 500 includes a computing unit 501, which can perform various appropriate actions and processes according to a computer program stored in a read-only memory (ROM) 502 or a computer program loaded from a storage unit 508 into a random access memory (RAM) 503. The RAM 503 may also store various programs and data required for the operation of the electronic device 500. The computing unit 501, ROM 502, and RAM 503 are interconnected via a bus 504. An input / output (I / O) interface 505 is also connected to the bus 504.

[0076] Multiple components in electronic device 500 are connected to I / O interface 505, including: input unit 506, such as keyboard, mouse, etc.; output unit 507, such as various types of monitors, speakers, etc.; storage unit 508, such as disk, optical disk, etc.; and communication unit 509, such as network card, modem, wireless transceiver, etc. Communication unit 509 allows electronic device 500 to exchange information / data with other devices through computer networks such as the Internet and / or various telecommunications networks.

[0077] The computing unit 501 can be a variety of general-purpose and / or special-purpose processing components with processing and computing capabilities. Some examples of the computing unit 501 include, but are not limited to, a central processing unit (CPU), a graphics processing unit (GPU), various special-purpose artificial intelligence (AI) computing chips, various computing units running machine learning model algorithms, a digital signal processor (DSP), and any suitable processor, controller, microcontroller, etc. The computing unit 501 performs the various methods and processes described above, such as the courseware content generation method. For example, in some embodiments, the courseware content generation method may be implemented as a computer software program tangibly contained in a machine-readable medium, such as storage unit 508. In some embodiments, part or all of the computer program may be loaded and / or installed on the electronic device 500 via ROM 502 and / or communication unit 509. When the computer program is loaded into RAM 503 and executed by the computing unit 501, one or more steps of the courseware content generation method described above may be performed. Alternatively, in other embodiments, the computing unit 501 may be configured to perform the courseware content generation method by any other suitable means (e.g., by means of firmware).

[0078] Various embodiments of the systems and techniques described above herein can be implemented in digital electronic circuit systems, integrated circuit systems, field-programmable gate arrays (FPGAs), application-specific integrated circuits (ASICs), application-specific standard products (ASSPs), systems-on-a-chip (SoCs), payload-programmable logic devices (CPLDs), computer hardware, firmware, software, and / or combinations thereof. These various embodiments may include implementations in one or more computer programs that can be executed and / or interpreted on a programmable system including at least one programmable processor, which may be a dedicated or general-purpose programmable processor, capable of receiving data and instructions from a storage system, at least one input device, and at least one output device, and transmitting data and instructions to the storage system, the at least one input device, and the at least one output device.

[0079] The program code used to implement the methods of this disclosure may be written in any combination of one or more programming languages. This program code may be provided to the processor or controller of a general-purpose computer, special-purpose computer, or other programmable courseware content generation device, such that when executed by the processor or controller, the patterns / operations specified in the flowcharts and / or block diagrams are implemented. The program code may be executed entirely on a machine, partially on a machine, as a standalone software package partially on a machine and partially on a remote machine, or entirely on a remote machine or server.

[0080] In the context of this disclosure, a machine-readable medium can be a tangible medium that may contain or store a program for use by or in conjunction with an instruction execution system, apparatus, or device. A machine-readable medium can be a machine-readable signal medium or a machine-readable storage medium. A machine-readable medium can be, but is not limited to, electronic, magnetic, optical, electromagnetic, infrared, or semiconductor systems, apparatus, or devices, or any suitable combination of the foregoing. More specific examples of machine-readable storage media include electrical connections based on one or more wires, portable computer disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination of the foregoing.

[0081] To provide interaction with a user, the systems and techniques described herein can be implemented on a computer having: a display device for displaying information to the user (e.g., a CRT (cathode ray tube) or LCD (liquid crystal display) monitor); and a keyboard and pointing device (e.g., a mouse or trackball) through which the user provides input to the computer. Other types of devices can also be used to provide interaction with the user; for example, feedback provided to the user can be any form of sensory feedback (e.g., visual feedback, auditory feedback, or tactile feedback); and input from the user can be received in any form (including sound input, voice input, or tactile input).

[0082] The systems and technologies described herein can be implemented in computing systems that include backend components (e.g., as a data server), or computing systems that include middleware components (e.g., an application server), or computing systems that include frontend components (e.g., a user computer with a graphical user interface or web browser through which a user can interact with implementations of the systems and technologies described herein), or any combination of such backend, middleware, or frontend components. The components of the system can be interconnected via digital data communication of any form or medium (e.g., a communication network). Examples of communication networks include local area networks (LANs), wide area networks (WANs), and the Internet.

[0083] It should be understood that the various forms of processes shown above can be used to rearrange, add, or delete steps. For example, the steps described in this disclosure can be executed in parallel, sequentially, or in different orders, as long as the desired result of the technical solution disclosed in this disclosure can be achieved, and this is not limited herein.

[0084] The foregoing description of specific exemplary embodiments of this disclosure is for illustrative and explanatory purposes. These descriptions are not intended to limit this disclosure to the precise forms disclosed, and it will be apparent that many changes and variations can be made in accordance with the foregoing teachings. The exemplary embodiments were chosen and described in order to explain the specific principles of this disclosure and their practical application, thereby enabling those skilled in the art to implement and utilize various different exemplary embodiments of this disclosure, as well as various different choices and variations. The scope of this disclosure is intended to be defined by the claims and their equivalents.

Claims

1. A method for generating courseware content, applied on a server, wherein the server is pre-configured with a heterogeneous pipeline set, the method comprising: Receive a personalized courseware generation request sent by the client, wherein the personalized courseware generation request includes a target entity identifier and a target user feature identifier; Based on the target user feature identifier and the target entity identifier, at least one target dimension node is identified as a courseware dimension node in the pre-stored courseware state tree that has not hit the cache or whose parameters have changed. Based on the node type of the at least one target dimension node, a corresponding heterogeneous pipeline is selected from the heterogeneous pipeline set. A corresponding processing task is generated based on the target entity identifier and / or the target user feature identifier. The processing task is distributed in parallel to the mutually isolated heterogeneous pipelines. The current load data returned by each heterogeneous pipeline is collected. The heterogeneous pipeline set includes at least a non-large language model query pipeline and a large language model inference pipeline. For each target dimension node, a cryptographic hash function is used to independently hash the current payload data of that target dimension node to generate the corresponding current node hash value; Based on the current node hash value of each target dimension node and the node hash value of the corresponding dimension node that has not changed in the courseware state tree, calculate the current root hash value and update the courseware state tree. The client is sent the current payload data, the current node hash value, and the current root hash value of the at least one target dimension node, so that the client can update the local courseware content based on the current payload data, the current node hash value, and the current root hash value.

2. The method according to claim 1, characterized in that, Before receiving the personalized courseware generation request sent by the client, the method further includes: Based on the initial courseware generation request, node load data of nodes with different dimensions are obtained in parallel through multiple isolated heterogeneous pipelines. The initial courseware generation request includes: user feature identifier; The node load data is assembled into an initial state tree according to a preset tree data model; The node hash value of each dimension node is calculated using a cryptographic hash function, and the hash values ​​of each node are concatenated bit by bit to generate the root hash value of the initial state tree, thus obtaining the courseware state tree.

3. The method according to claim 2, characterized in that, The tree-like data model includes: a root node, representing the courseware entity; and multiple logically isolated dimension nodes, which are child nodes of the root node. The dimension nodes include: courseware target node, courseware value node, courseware strategy node, courseware history node, and courseware interaction node. The data structure of each dimension node includes a component mounting instruction field, a structured payload field, and an external resource pointer field. Before sending the current payload data, the current node hash value, and the current root hash value of the at least one target dimension node to the client, the method further includes: Obtain the user permission level corresponding to the target user feature identifier; Based on the user permission level, configure the data access control list for each field in the target dimension node at the gateway layer; In response to the target dimension node including an external resource pointer field and the user's permission level being lower than a preset threshold, the issuance of the external resource pointer field is blocked, and only the component mounting instruction field and the structured payload field are issued; after blocking the external resource pointer field, the current node hash value is re-normalized and encoded based on the set of fields issued to the client.

4. The method according to claim 1, characterized in that, Before generating the corresponding current node hash value by independently hashing the current payload data of each target dimension node using a cryptographic hash function, the method further includes: In response to the target dimension node belonging to the courseware target node or the courseware interaction node, the core behavioral verbs in the current load data are extracted and the core behavioral verbs are converted into word embedding vectors; The cosine similarity between the word embedding vector and the standard verb vector in the preset curriculum standard knowledge graph database is calculated. If the cosine similarity is less than a preset gating threshold, the current payload data is intercepted and a system degradation strategy is triggered. The system degradation strategy includes: discarding the current payload data output by the large language model inference pipeline, and extracting the default standard payload data associated with the target entity identifier from the curriculum standard knowledge graph database as the current payload data.

5. The method according to claim 1, characterized in that, The node types of the at least one target dimension node include: courseware objective, courseware value, courseware strategy, courseware history, and courseware interaction; the step of selecting a corresponding heterogeneous pipeline from the heterogeneous pipeline set according to the node types of the at least one target dimension node, generating a corresponding processing task based on the target entity identifier and / or the target user feature identifier, and distributing the processing task in parallel to the mutually isolated heterogeneous pipelines includes: In response to the node type of the target dimension node being any one of courseware target, courseware value, or courseware history, the corresponding non-large language model query pipeline is selected from the heterogeneous pipeline set, and the processing task including the target entity identifier is distributed to the non-large language model query pipeline. In response to the target dimension node's node type being a courseware strategy, a corresponding non-large language model query pipeline is selected from the heterogeneous pipeline set, and the processing task including the target user feature identifier is distributed to the non-large language model query pipeline. In response to the node type of the target dimension node being courseware interaction, a large language model inference pipeline is selected from the heterogeneous pipeline set, and the processing task including the target user feature identifier is distributed to the large language model inference pipeline.

6. The method according to claim 5, characterized in that, The steps for each non-large language model query pipeline to process the processing task include: In response to the node type being a courseware target, a structured query statement is executed based on the target entity identifier through the database query pipeline, and standard action enumeration values ​​are output. In response to the node type being courseware value, the target entity identifier is converted into an entity vector through a vector query pipeline, and a nearest neighbor search is performed in a preset vector retrieval library to output an external resource pointer; In response to the node type being a courseware strategy, the target user feature identifier is converted into a user vector through a parameter query pipeline; the user vector is then input into a preset collaborative filtering recommendation algorithm matrix, and component mounting instructions and initialization parameters are output. In response to the node type being courseware history, the database query pipeline executes a graph database query statement based on the target entity identifier and outputs historical evolution data including the topological relationships between nodes and edges.

7. The method according to claim 5, characterized in that, The steps of the large language model inference pipeline for processing the processing task include: Based on the target user feature identifier in the processing task, a prompt word template with preset restrictions is injected into the large language model to limit the maximum number of word elements generated by the model. Logical parameters are input into the large language model so that the large language model outputs state machine controller instructions that conform to a preset structured field protocol as the current load data.

8. A courseware content generation device, applied to a server, wherein the server is pre-configured with a heterogeneous pipeline set, the device comprising: The receiving unit is configured to receive a personalized courseware generation request sent by the client, wherein the personalized courseware generation request includes a target entity identifier and a target user feature identifier; The determining unit is configured to determine at least one target dimension node in the pre-stored courseware state tree that has not been cached or whose parameters have changed, based on the target user feature identifier and the target entity identifier. The allocation unit is configured to select a corresponding heterogeneous pipeline from the heterogeneous pipeline set according to the node type of the at least one target dimension node, generate a corresponding processing task based on the target entity identifier and / or the target user feature identifier, distribute the processing task in parallel to the mutually isolated heterogeneous pipelines, and collect the current load data returned by each heterogeneous pipeline. The heterogeneous pipeline set includes at least a non-large language model query pipeline and a large language model inference pipeline. The hash calculation unit is configured to perform independent hash calculation on the current payload data of each target dimension node using a cryptographic hash function to generate the corresponding current node hash value. The hash calculation unit is configured to calculate the current root hash value based on the current node hash value of each target dimension node and the node hash value of the corresponding dimension node that has not changed in the courseware state tree, and update the courseware state tree. The delivery unit is configured to send the current payload data, the current node hash value, and the current root hash value of the at least one target dimension node to the client, so that the client can update the local courseware content based on the current payload data, the current node hash value, and the current root hash value.

9. An electronic device, characterized in that, include: At least one processor; and a memory communicatively connected to the at least one processor; The memory stores instructions that can be executed by the at least one processor to enable the at least one processor to perform the method of any one of claims 1-7.

10. A computer-readable storage medium storing computer instructions thereon, characterized in that, The computer instructions are used to cause the computer to perform the method according to any one of claims 1-7.

Images