A task chain construction method and system for a skill practical training platform and a medium

Abstract

The application provides a task chain construction method and system for a skill training platform, and a medium, comprising: acquiring external demand data flow associated with a target object identifier in the skill training platform, the external demand data flow including a plurality of skill demand description texts with time sequence marks; performing entity extraction processing on the external demand data flow to obtain a plurality of skill demand characteristic entities; determining a demand weight value of each skill demand characteristic entity according to the occurrence frequency and time sequence mark of the skill demand characteristic entity in the external demand data flow; taking the skill demand characteristic entity as a graph node, and writing the demand weight value into an attribute parameter of the corresponding graph node to obtain a skill demand characteristic graph; and matching a corresponding target task unit based on the skill demand characteristic graph, and then generating a target task chain for the target object identifier. The application can ensure that the constructed task chain is synchronized with the real-time changing external skill demand environment, and improve the timeliness of the task chain.

Description

Technical Field

[0001] This application relates to the field of skills training technology, specifically to a method, system, and medium for constructing task chains for skills training platforms. Background Technology

[0002] In skills training platforms, constructing task chains based on target skill requirements is a key technology for achieving automated resource management. The construction of task chains typically relies on a pre-built relational database, which stores fixed mappings between skill characteristic attributes and task units. For example, by querying pre-built fixed mappings, corresponding task units can be matched, thereby constructing a task chain.

[0003] However, the timeliness of task chains built on fixed mapping relationships is often poor and cannot meet current actual skill requirements. Summary of the Invention

[0004] The embodiments of this application provide a method, system, and medium for constructing task chains for skills training platforms, aiming to improve the timeliness of the constructed task chains.

[0005] In a first aspect, embodiments of this application provide a task chain construction method for a skills training platform, the task chain construction method for a skills training platform comprising:

[0006] Obtain the external demand data stream associated with the target object identifier in the skills training platform. The external demand data stream includes multiple skill demand description texts with time sequence markers.

[0007] The external demand data stream is subjected to entity extraction processing to obtain multiple skill demand feature entities;

[0008] Based on the frequency of occurrence of the skill requirement feature entity in the external requirement data stream and the time sequence marker, determine the requirement weight value of each skill requirement feature entity;

[0009] The skill demand feature entity is used as a graph node, and the demand weight value is written into the attribute parameters of the corresponding graph node to obtain a skill demand feature graph.

[0010] Based on the skill requirement feature map, the corresponding target task unit is matched from the preset task unit library;

[0011] Based on the target task unit, a target task chain is generated targeting the target object identifier.

[0012] In the above embodiments, by collecting and parsing external time-series data in real time, a dynamically weighted skill demand feature map is constructed, and abstract market skill demands are automatically mapped to specific execution task units. This solution can eliminate information asymmetry, ensure that the generated execution sequence remains synchronized with the real-time changing external skill demand environment, and realize the automated and precise derivation from macro goals to micro operational paths, effectively improving the scientific nature and real-time adaptability of the execution plan.

[0013] In one embodiment, determining the demand weight value of each skill requirement feature entity based on its frequency of occurrence in the external demand data stream and the time sequence marker includes:

[0014] Determine the time difference between the timing marker and the current system time;

[0015] Based on the time difference, determine the time decay coefficient of the corresponding skill requirement feature entity;

[0016] Based on the time decay coefficient and the frequency of occurrence, the demand weight value of the corresponding skill demand feature entity is determined.

[0017] In the above embodiments, by introducing dynamic decay calculation logic based on time difference, the frequency data is weighted and corrected using the time decay coefficient, so that the generated feature map can accurately reflect the real skill demand of the current time segment, effectively eliminating the interference of outdated information, and ensuring that the task chain constructed subsequently has extremely high market sensitivity and timeliness value.

[0018] In one embodiment, matching the corresponding target task unit from a preset task unit library based on the skill requirement feature map includes:

[0019] In the skill requirement feature map, the target map node is determined;

[0020] For each preset task unit in the task unit library, determine the content coverage index, difficulty gradient matching degree, and historical contribution effectiveness coefficient between the preset task unit and the target graph node;

[0021] Based on the content coverage index, the difficulty gradient matching degree, and the historical contribution validity coefficient, the matching score between the preset task unit and the target map node is determined.

[0022] Based on the matching score, the target task unit is determined from the task unit library.

[0023] In the above embodiments, a multi-dimensional evaluation system encompassing semantic coverage, difficulty adaptation, and historical performance is constructed to achieve precise mapping between task units and requirement nodes. This solution not only ensures the consistency of selected tasks in terms of knowledge points but also guarantees the executability and practical effectiveness of tasks by introducing difficulty matching and historical data verification, thereby generating high-quality, high-conversion-rate execution sequences.

[0024] In one embodiment, determining the target task unit from the task unit library based on the matching score includes:

[0025] Based on the demand weight values ​​of the target graph nodes, the number of target tasks is determined, and the number of target tasks is positively correlated with the demand weight values ​​of the target graph nodes;

[0026] Based on the matching score, the target task units that match the number of target tasks are determined from the task unit library.

[0027] In the above embodiments, by establishing a positive correlation mapping mechanism between the number of tasks and feature weights, the automation and intelligence of resource allocation are achieved. This solution can dynamically adjust the execution load according to the urgency of market skill demands, automatically increasing the training proportion for high-value core skills and simplifying training for peripheral skills, thereby effectively optimizing overall execution efficiency and time costs while ensuring the construction of core competitiveness.

[0028] In one embodiment, generating a target task chain for the target object identifier based on the target task unit includes:

[0029] Construct a directed acyclic graph including the target task units;

[0030] Obtain historical execution log data of the target object identifier, wherein the historical execution log data includes historically completed tasks;

[0031] Based on the completed tasks in the history, the directed acyclic graph is pruned to obtain a processed directed acyclic graph.

[0032] Based on the processed directed acyclic graph, a target task chain is generated for the target object identifier.

[0033] In the above embodiments, by constructing a task dependency graph and combining it with user historical data for dynamic pruning, intelligent deduplication and personalized customization of execution paths are achieved. This solution can automatically identify and remove historical tasks already completed by the user, avoiding resource waste caused by repeated training, ensuring that the generated task chain always focuses on the user's skill gaps, and significantly improving the accuracy of task planning and execution efficiency.

[0034] In one embodiment, generating a target task chain for the target object identifier based on the processed directed acyclic graph includes:

[0035] Obtain the estimated execution time for each node in the processed directed acyclic graph;

[0036] The estimated execution time is mapped to the weight value of the corresponding node in the directed acyclic graph;

[0037] With the goal of minimizing the sum of weights on the path, Dijkstra's algorithm is used to determine the target path sequence from the start node to the end node in the directed acyclic graph.

[0038] Based on the target path sequence, a target task chain is generated targeting the target object identifier.

[0039] In the above embodiments, by introducing a time dimension as the core cost function and utilizing the shortest path algorithm to automatically search for the optimal solution in complex task dependency networks, a task chain construction oriented towards time efficiency is achieved. This scheme can automatically plan the execution path with the shortest total time and highest efficiency when multiple technical routes or execution branches exist, reducing the user's time cost and maximizing execution benefits.

[0040] In one embodiment, after generating the target task chain for the target object identifier based on the target task unit, the method further includes:

[0041] Receive execution feedback data for the current task execution node in the target task chain, the execution feedback data including a task execution completion score;

[0042] Based on the task completion score, the target task chain is processed by inserting or deleting task execution nodes.

[0043] In the above embodiments, by introducing dynamic link reconstruction logic based on real-time feedback, the task chain is adaptively matched to the user's actual capabilities. This scheme can automatically insert tutoring tasks to reduce the gradient when the user performs poorly, and automatically remove redundant tasks to improve efficiency when the user performs well, thereby transforming the static plan into a dynamic personalized guidance path, ensuring the smoothness and efficiency of the execution process.

[0044] In one embodiment, the step of inserting or deleting task execution nodes in the target task chain based on the task completion score includes at least one of the following steps:

[0045] If the execution completion score is less than a preset first threshold, obtain the task unit to be supplemented that matches the current task execution node from the task unit library, and perform task execution node insertion processing on the target task chain based on the task unit to be supplemented.

[0046] If the execution completion score is greater than a preset second threshold, in the target task chain, a task execution node to be skipped is determined that is located after the current task execution node and has a task difficulty level less than a preset level threshold. Based on the task execution node to be skipped, the target task chain is deleted. The second threshold is greater than or equal to the first threshold.

[0047] In the above embodiments, by automatically inserting downgrade tutoring tasks when scores are low and automatically removing low-level redundant tasks when scores are high, this scheme enables the task chain to scale and adapt according to the user's real-time performance. This not only effectively solves the problem of users experiencing lag due to weak foundations, but also avoids high-level users wasting time by repeatedly practicing low-difficulty tasks, maximizing the output of ability improvement per unit of time.

[0048] Secondly, embodiments of this application provide a task chain construction system for a skills training platform, the task chain construction system for a skills training platform being used to execute the task chain construction method for a skills training platform as described in any of the preceding claims.

[0049] Thirdly, embodiments of this application provide a computer-readable storage medium storing a computer program configured to be executed by a processor to implement the task chain construction method for a skills training platform as described in any of the preceding claims.

[0050] The beneficial effects of the embodiments of this application are as follows:

[0051] In the embodiments of this application, multiple skill requirement feature entities are obtained by performing entity extraction processing on the external demand data stream. Based on the frequency of occurrence and time sequence marker of the skill requirement feature entities in the external demand data stream, the demand weight value of each skill requirement feature entity is determined, thereby constructing a dynamically weighted skill requirement feature map and mapping it to specific target task units to generate target task chains. This eliminates information asymmetry and ensures that the generated target task chains remain synchronized with the real-time changing external skill requirement environment, achieving accurate derivation from macro-level external skill requirements to micro-level target task chains, and improving the timeliness and accuracy of task chains. Attached Figure Description

[0052] To more clearly illustrate the technical solutions in the embodiments of this application, the accompanying drawings used in the description of the embodiments will be briefly introduced below. Obviously, the accompanying drawings described below are only some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0053] Figure 1 This is a schematic flowchart of an embodiment of the task chain construction method for a skills training platform provided in this application. Detailed Implementation

[0054] The technical solutions of the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, and not all embodiments. Based on the embodiments of this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application. In addition, in the description of this application, "multiple" means two or more, unless otherwise explicitly specified.

[0055] In a first aspect, embodiments of this application provide a task chain construction method for a skills training platform, wherein the execution subject is a task chain construction system for a skills training platform (hereinafter referred to as the "system").

[0056] Specifically, refer to Figure 1 The task chain construction method for skills training platforms may include:

[0057] S101. Obtain the external demand data stream associated with the target object identifier in the skills training platform. The external demand data stream includes multiple skill demand description texts with time sequence markers.

[0058] In the embodiments of this application, the skills training platform refers to a computer software system that provides skills training functions such as online programming practice, virtual simulation operation, and vocational skills assessment. The target object identifier refers to a digital fingerprint or character sequence used to uniquely identify the subject requesting data processing, and it is associated with a specific target domain label, such as a career path like a front-end development engineer or data analyst in computer software engineering. The external demand data stream refers to a collection of unstructured data captured in real time or imported in batches from third-party data sources (such as open interfaces of recruitment platforms, industry technical forums, or project bidding systems). The time sequence marker refers to the specific timestamp of each data point generated or published, used to indicate the timeliness of the data. The skills requirement description text refers to a text paragraph that describes the job's capabilities, technology stack requirements, or project delivery standards in natural language, such as a character stream containing content like "proficient in Python multithreaded programming" or "familiar with Docker containerized deployment."

[0059] In some embodiments of this application, the acquisition process is executed through a preset Application Programming Interface (API) or a web crawler. Based on keywords mapped to the target object identifier (e.g., "Java architect"), the system initiates a search request to distributed network nodes, filters out duplicate and invalid data, and retains data within the most recent preset time window (e.g., 30 days) to form a highly timely external demand data stream. Through this step, the system can capture the latest technological trends in the industry, overcoming the deficiency of static databases in reflecting real-time market changes.

[0060] S102. Perform entity extraction processing on the external demand data stream to obtain multiple skill demand feature entities;

[0061] In the embodiments of this application, entity extraction processing refers to the process of identifying and extracting words or phrases with specific meanings from unstructured text using Natural Language Processing (NLP) technology. Skill requirement feature entities refer to the smallest semantic unit representing a specific technical capability, tool name, framework name, or theoretical concept, i.e., a "skill atom." For example, "SpringBoot" and "microservices" are extracted as skill requirement feature entities from "able to build microservices using Spring Boot."

[0062] In some embodiments of this application, entity extraction processing can be performed using a deep learning-based Named Entity Recognition (NER) model. The system pre-loads a domain-specific technical dictionary, enabling it to identify technical terms and their synonym variants (e.g., normalizing "JS" and "JavaScript" to the same entity). Entity extraction processing transforms ambiguous textual descriptions into computer-computable structured symbols, providing a foundational data dimension for subsequent quantitative analysis.

[0063] S103. Determine the demand weight value of each skill demand feature entity based on the frequency of occurrence and time sequence marker of the skill demand feature entity in the external demand data stream.

[0064] In the embodiments of this application, frequency of occurrence refers to the number of times a specific skill requirement feature entity is mentioned in the collected sample set. This indicator reflects the market penetration or popularity of the skill. The demand weight value is a quantitative value used to characterize the importance of the entity in achieving the goal.

[0065] S104. Use skill demand feature entities as graph nodes and write the demand weight values ​​into the attribute parameters of the corresponding graph nodes to obtain the skill demand feature graph.

[0066] In the embodiments of this application, the skill requirement feature graph is a data structure that stores knowledge and data relationships in a graph structure, including nodes and edges. Graph nodes are the storage form of skill requirement feature entities in a graph database. Attribute parameters refer to key-value pair data stored inside the nodes, including but not limited to weight values, ability level requirements (such as beginner, intermediate, and advanced), and the classification of the technical field.

[0067] In some embodiments of this application, the construction process of the skill demand feature map includes creating a virtual root node and connecting all extracted skill demand feature entities as child nodes to the root node, or establishing connection edges between entities based on their co-occurrence relationships. The calculated demand weight values ​​are written into the metadata fields of the nodes, realizing the transformation from unstructured text to a weighted map. This weighted map intuitively displays the overall skill landscape required to achieve the goal and its priority distribution, providing a weighted search space for subsequent path planning.

[0068] S105. Based on the skill requirement feature map, match the corresponding target task unit from the preset task unit library;

[0069] In the embodiments of this application, the preset task unit library is a database in the skills training platform that stores specific execution instructions, operation items, or practice questions. Each unit has clear input and output standards and assessment points. The target task unit refers to the specific execution action selected to cover the specific skill requirement characteristics entity, such as "writing a Flask-based Hello World program".

[0070] In some embodiments of this application, the matching process for target task units is not a simple keyword matching, but rather based on similarity calculation in the semantic vector space or multi-dimensional feature alignment. The system traverses high-weight nodes in the skill requirement feature graph and retrieves tasks from the task unit library that can cover the knowledge points represented by the node. For example, for the high-weight graph node "asynchronous programming," the system will match the specific task unit "using the Python asyncio library to implement concurrent requests." This step realizes the mapping from "abstract ability requirements" to "specific execution actions," solving the problem that users know what to learn but don't know how to practice.

[0071] S106. Generate a target task chain for the target object identifier based on the target task unit.

[0072] In the embodiments of this application, the target task chain refers to a sequence of task units arranged in a specific logical order, which is usually represented by a linear list or a directed acyclic graph structure, representing the operation path that the user needs to perform from the current state to achieve the target state.

[0073] In some embodiments of this application, the generation process of the target task chain includes dependency analysis of multiple selected target task units. The system reads the preconditions from the task unit metadata and sorts the tasks according to logical dependencies (e.g., mastering the syntax before writing the algorithm) to form an executable sequence. Simultaneously, based on the weight values ​​of the graph nodes, the system can arrange high-weight core tasks on the core path to ensure that users prioritize mastering the skills most urgently needed in the market.

[0074] As can be seen, this application embodiment constructs a dynamically weighted skill demand feature map by collecting and parsing external time-series data in real time, and automatically maps abstract market skill demands into specific execution task units. This solution can eliminate information asymmetry, ensure that the generated execution sequence remains synchronized with the real-time changing external skill demand environment, and realize the automated and precise derivation from macro goals to micro operational paths, effectively improving the scientific nature and real-time adaptability of the execution plan.

[0075] In some embodiments of this application, the demand weight value of each skill requirement feature entity is determined based on its frequency of occurrence and time sequence marker in the external demand data stream, including:

[0076] S201. Determine the time difference between the timing mark and the current system time;

[0077] In the embodiments of this application, the current system time refers to the standard clock time on the server side when data processing operations are performed. The time difference refers to the interval between the publication or update time of each piece of data in the external demand data stream and the current time, usually in days or hours.

[0078] In some embodiments of this application, the system obtains the time stamp by parsing the metadata field in the packet header and subtracts it from the system clock to obtain the difference. For example, even if a certain technology frequently appears in documents from three years ago, if the time difference is too large, it indicates that the data is outdated information. This step provides the basic variable for subsequent weighted calculations with a time dimension, ensuring that the system can identify the decay of information value due to the passage of time.

[0079] S202. Determine the time decay coefficient of the corresponding skill requirement characteristic entity based on the time difference;

[0080] In the embodiments of this application, the time decay coefficient is a value between 0 and 1, used to quantify the timeliness value of information. This coefficient decreases monotonically as the time difference increases.

[0081] In some embodiments of this application, an exponential decay function is used to calculate the time decay coefficient. The half-life parameter λ is set, and the time decay coefficient D(t) = e -λt Where t is the time difference. For example, in the field of software development, where technology iterates rapidly, λ is set to a larger value so that the coefficient of data older than six months quickly approaches 0; in the field of basic sciences, λ is set to a smaller value. Through this non-linear coefficient mapping, the system can significantly reduce the impact of outdated data on the results, thereby keenly capturing emerging trends in a dynamically changing environment. For example, if a new technology is frequently mentioned in the past month, even if the total frequency is not high, it can still gain attention due to its extremely high time decay coefficient (close to 1).

[0082] S203. Based on the time decay coefficient and frequency of occurrence, determine the demand weight value of the corresponding skill demand characteristic entity.

[0083] In the embodiments of this application, the demand weight value is a comprehensive indicator ultimately used to measure the importance of a node. This step incorporates timeliness factors into frequency statistics through weighted summation or multiplication.

[0084] In some embodiments of this application, the calculation formula is: W(e) = sum[F(e, d) × D(t_d)], where W(e) is the demand weight value of skill demand feature entity e, F(e, d) is the frequency of occurrence of skill demand feature entity e in a single data point d, and D(t_d) is the time decay coefficient corresponding to the single data point d. The system traverses all data entries containing the skill demand feature entity and accumulates its frequency contribution after time correction. This calculation method overcomes the historical inertia error caused by simply relying on cumulative frequency, thus reducing the weight of "outdated" technologies (such as Flash development) that have a large historical total but are currently neglected, while effectively increasing the weight of technologies that have recently experienced explosive growth (such as Artificial Intelligence Generated Content (AIGC) application development).

[0085] As can be seen, the embodiments of this application introduce dynamic decay calculation logic based on time difference and use time decay coefficient to weight and correct frequency data, so that the generated feature map can accurately reflect the real skill demand of the current time segment, effectively eliminate the interference of outdated information, and ensure that the task chain constructed subsequently has extremely high market sensitivity and timeliness value.

[0086] In some embodiments of this application, matching corresponding target task units from a preset task unit library based on a skill requirement feature map includes:

[0087] S301. Identify the target graph nodes in the skill demand feature graph;

[0088] In the embodiments of this application, a target graph node refers to a node in the generated skill requirement feature graph that has a high priority attribute or belongs to the critical path, representing the core capability entity that must be mastered to achieve the professional or business goal associated with the target object identifier.

[0089] In some embodiments of this application, the system traverses all nodes in the skill demand feature map and reads the demand weight value from the attribute parameters of each node. The system marks nodes with demand weight values ​​greater than a preset threshold, or nodes that rank at the top of a preset proportion after being sorted by demand weight values ​​from high to low, as target map nodes. In addition, the system can also combine the current state of the target object identifier to exclude those nodes that, although they have high weights, have already been marked as "mastered," thereby focusing on the skill gaps that need to be improved.

[0090] S302. For each preset task unit in the task unit library, determine the content coverage index, difficulty gradient matching degree, and historical contribution validity coefficient between the preset task unit and the target map node.

[0091] In the embodiments of this application, the preset task unit is the smallest execution unit stored in the task unit library, which includes knowledge point tags, operation difficulty level and historical statistics.

[0092] Content coverage metrics characterize the degree of overlap between the set of knowledge points contained in a task unit and the skill semantics represented by the target graph node. In some embodiments of this application, the system uses natural language processing technology to extract the feature vector of the descriptive text of the preset task unit, calculates its cosine similarity with the feature vector of the target graph node, or calculates the Jaccard similarity coefficient between the metadata tag set of the task unit and the set of sub-concepts associated with the graph node, as the content coverage metric.

[0093] The difficulty gradient matching degree characterizes the distance between the difficulty setting of a task unit and the required ability level of the target graph node. In some embodiments of this application, the system obtains the ability level requirement (e.g., "proficiency" corresponds to level 5) in the target graph node attributes and the difficulty label level of the preset task unit (e.g., level 3). The system uses a Gaussian distribution function or the reciprocal distance formula to calculate the matching degree between the two. For preset task units and target graph nodes whose difficulty label level is slightly higher than or equal to the ability level requirement (e.g., the difference between the difficulty label level and the ability level requirement is greater than zero and less than or equal to a preset value (e.g., a value of 2)), a larger difficulty gradient matching degree is assigned to stimulate user potential; while for preset task units and target graph nodes whose difficulty label level and ability level requirement differ too much, a smaller difficulty gradient matching degree is assigned.

[0094] The historical contribution effectiveness coefficient represents the success rate of a task in actually mastering a skill, derived from statistical analysis of historical data of the group. In some embodiments of this application, the system queries historical logs to statistically analyze the pass rate or score improvement of historical users who completed the preset task unit in subsequent skill assessments targeting the target graph node. The greater the improvement, the higher the historical contribution effectiveness coefficient, thereby quantifying the practical value of the task.

[0095] S303. Based on the content coverage index, difficulty gradient matching degree, and historical contribution validity coefficient, determine the matching score between the preset task unit and the target map node;

[0096] In the embodiments of this application, the matching score is a comprehensive numerical value used to rank the suitability of task units.

[0097] In some embodiments of this application, the system employs a multi-factor linear weighted model for calculation. The system pre-sets weight coefficients for each indicator, and then weights and sums the normalized content coverage indicator, difficulty gradient matching degree, and historical contribution effectiveness coefficient to obtain a matching score. This matching score considers not only "whether the content is correct," but also "whether the difficulty is appropriate" and "whether the effect is good."

[0098] S304. Based on the matching score, determine the target task unit from the task unit library.

[0099] In some embodiments of this application, the system sorts all candidate preset task units for the same target map node in descending order of matching score, and selects the top-ranked preset number of task units (Top-K) as the target task units. Alternatively, the system sets a scoring threshold and retains only task units with scores higher than the threshold, thereby filtering out low-quality or irrelevant tasks.

[0100] As can be seen, this application's embodiments achieve precise mapping between task units and requirement nodes by constructing a multi-dimensional evaluation system that includes semantic coverage, difficulty adaptation, and historical performance. This solution not only ensures the consistency of selected tasks in terms of knowledge points, but also guarantees the executability and practical effectiveness of tasks by introducing difficulty matching and historical data verification, thereby generating high-quality, high-conversion-rate execution sequences.

[0101] In some embodiments of this application, the target task unit is determined from the task unit library based on a matching score, including:

[0102] S401. Determine the number of target tasks based on the demand weight values ​​of the target graph nodes;

[0103] In the embodiments of this application, the number of target tasks refers to the number of execution units that should be included in the final task chain for a single target graph node. The number of target tasks can be positively correlated with the demand weight value of the target graph node. Positive correlation means that as the demand weight value increases, the corresponding number of task allocations increases. The design basis of this logic is that a node with a higher demand weight value represents a higher importance in the external demand data stream, and therefore requires more computing resources or training frequency to ensure that this key feature is fully covered or mastered.

[0104] S402. Based on the matching score, determine the target task units that match the number of target tasks from the task unit library.

[0105] In some embodiments of this application, the system first obtains the matching scores of all candidate preset task units for the target graph node, and constructs a sorting sequence of the candidate preset task units according to the matching scores from high to low. Then, starting from the top of this sorting sequence, the system sequentially extracts a number of preset task units equal to the number of target tasks, and confirms this set of extracted units as the final target task units. If the total number of task units meeting the conditions in the candidate library is less than the number of target tasks, the system will select all usable task units and may generate a gap log to prompt the administrator to expand the library. This step ensures that the tasks selected into the final execution sequence not only meet the weight configuration in quantity but are also the optimal solutions in the current library in terms of quality.

[0106] As can be seen, this application's embodiments achieve automated and intelligent resource allocation by establishing a positive correlation mapping mechanism between the number of tasks and feature weights. This solution can dynamically adjust the execution load according to the urgency of market skill demands, automatically increasing the training weight for high-value core skills while streamlining training for peripheral skills. This effectively optimizes overall execution efficiency and time costs while ensuring the construction of core competitiveness.

[0107] In some embodiments of this application, generating a target task chain for a target object identifier based on the target task unit includes:

[0108] S501. Construct a directed acyclic graph that includes the target task units;

[0109] In the embodiments of this application, a Directed Acyclic Graph (DAG) is a graph theory data structure used to represent acyclic dependencies between multiple target task units. Nodes in the graph represent specific target task units, and directed edges represent the logical order of task execution or prerequisite dependencies.

[0110] In some embodiments of this application, the system reads the metadata configuration of each target task unit and parses the defined "preceding task identifier" or "input parameter source" field. If the input of task B depends on the output of task A, or if task B requires that it can only start after task A is completed, the system constructs a directed edge from task A to task B. Through this step, the system organizes multiple discrete target task units into a structured graph with a strict logical temporal order, effectively preventing infinite loops or logical conflicts in the task execution process.

[0111] In the embodiments of this application, to ensure that the constructed graph is a directed acyclic graph (DAG), the system runs a loop detection algorithm when adding dependent edges. The specific process is as follows: The system maintains a temporary adjacency list. Before attempting to add an edge from task A to task B, it first checks whether there is a reachable path from task B to task A. If a reachable path is detected, it means that adding the edge will form a closed loop. At this time, the system triggers a conflict resolution mechanism: First, it queries the "dependency strength" of task A and task B. If the dependency relationship is marked as "weak dependency" or "suggested execution order," the system directly discards the edge and breaks the loop; if both are "strong dependencies," the system retains the newer task node based on the task creation timestamp, marks the older task node as "conflict pending manual review," and temporarily removes it from the graph, or automatically creates a virtual "decoupling intermediate node" to reconstruct the dependency relationship. This processing logic ensures that the generated graph structure always satisfies the topological properties of a DAG, avoiding the risk of deadlock.

[0112] S502. Obtain historical execution log data of the target object identifier. The historical execution log data includes historically completed tasks.

[0113] In the embodiments of this application, historical execution log data refers to a detailed record stored in the system database of every task operation performed by the target object identifier within a past time period, including task code, execution timestamp, execution result status, and performance score. Historical completed tasks refer to the set of tasks explicitly marked as "executed successfully," "passed assessment," or "accepted" in the log data.

[0114] In some embodiments of this application, the system uses the target object identifier as an index key to initiate a query request to the backend log server and retrieve all historical operation records. The system filters the raw logs, removing records that failed, were abandoned midway, or had expired results, and only extracts a list of completed task identifiers whose current status is still considered valid. This step aims to obtain a personalized capability profile of the user, providing data support for subsequent differentiated task planning.

[0115] S503. Based on the tasks already completed in the past, prune the directed acyclic graph to obtain the processed directed acyclic graph.

[0116] In the embodiments of this application, pruning refers to the operation of dynamically removing redundant nodes or invalid branches from a directed acyclic graph while keeping the original graph structure dependency logic unchanged.

[0117] In some embodiments of this application, the system traverses all nodes in the directed acyclic graph. For each node, the system determines whether its corresponding task identifier exists in the list of historical completed tasks. If it exists, it means that the task is already mastered by the current user or does not need to be repeated. The system removes the node from the graph and updates the connection relationships of related edges. For example, if the original graph is A→B→C, and A has been completed, the pruned graph structure becomes B→C, at which point node B becomes the starting node with an in-degree of 0. Through pruning, the system can eliminate existing skill tasks that the user has mastered, achieving personalized slimming of the task graph.

[0118] S504. Based on the processed directed acyclic graph, generate a target task chain for the target object identifier.

[0119] In some embodiments of this application, the system performs a topological sorting algorithm on the processed directed acyclic graph, transforming the complex graph structure into a linear execution list. For nodes in parallel relationships (i.e., nodes without direct dependencies), the system can perform a secondary sort based on task weight values, prioritizing tasks with higher weight values. The generated task chain contains only high-value tasks that the user has not yet mastered and needs to execute immediately, forming a customized growth path for that user.

[0120] As can be seen, this embodiment of the application achieves intelligent deduplication and personalized customization of execution paths by constructing a task dependency graph and combining it with user historical data for dynamic pruning. This solution can automatically identify and remove historical tasks that the user has already completed, avoiding the waste of resources caused by repeated training, ensuring that the generated task chain always focuses on the user's skill gaps, and significantly improving the accuracy of task planning and execution efficiency.

[0121] In some embodiments of this application, a target task chain for a target object identifier is generated based on the processed directed acyclic graph, including:

[0122] S601. Obtain the estimated execution time of each node in the processed directed acyclic graph;

[0123] In the embodiments of this application, the estimated execution time refers to the average time cost or standard working hours required to complete the target task unit corresponding to the node. This time not only reflects the complexity of the task itself, but also includes the time cost of necessary processes such as reading documents, writing code, and debugging and fixing.

[0124] In the embodiments of this application, for novel task units lacking historical execution data, the system employs a cold-start estimation model based on attribute regression to determine the estimated execution time. Specifically, the system pre-constructs a duration regression model, which uses the task's "text length" (e.g., reading volume), "number of lines of code / interaction steps" (representing the amount of operation), "knowledge point complexity coefficient" (representing the density of thought), and "task type" (e.g., multiple choice, question-and-answer, practical operation) as input features. When a new task is introduced, the system extracts the above features and inputs them into the regression model, outputting a baseline estimated execution time. For example, for a Python practice task containing 500 words of reading material and 10 lines of code to fill in the blanks, the model calculates a baseline execution time of 15 minutes based on the fitting curves of similar historical tasks. In addition, the system also introduces "similar task migration" logic, searching for existing tasks in the library with the highest semantic similarity to the new task (similarity > 0.9), and directly reusing the historical average execution time of such similar tasks as the estimated execution time of the new task.

[0125] In some embodiments of this application, the system reads the basic duration tag of the task from the metadata of a preset task unit library. Further, to improve the accuracy of the estimation, the system calls the historical user execution database to calculate the median or weighted average of the time consumed by all historical users to complete the task. In addition, the system can also combine the target object's personal historical efficiency factor (e.g., the user has consistently completed tasks of similar difficulty 20% faster than the average person) to personalize the basic duration, thereby obtaining the estimated execution time for that specific user.

[0126] S602. Map the estimated execution time to the weight value of the corresponding node in the directed acyclic graph;

[0127] In the embodiments of this application, the weight value specifically refers to the "cost" or "impedance" parameter in the path planning algorithm. In a graph model, weights are usually assigned to edges, while in this step, the system converts the node's attributes (duration) into the cumulative cost during the graph traversal process.

[0128] In some embodiments of this application, the mapping process employs a direct linear mapping, where the weight value equals the estimated execution time (e.g., 2 hours is mapped to a weight of 2.0). In more complex scenarios, the system can introduce a time urgency adjustment factor. If the target object identifier has a shorter overall deadline, tasks with longer execution times are given a non-linear, high-weight penalty to force the algorithm to avoid excessively time-consuming paths. To adapt to standard shortest path algorithms, the system can logically transfer the weight value of a node to all incoming edges pointing to that node, or include the inherent weight of the node when calculating the total path weight.

[0129] S603. Using Dijkstra's algorithm to determine the target path sequence from the start node to the end node in a directed acyclic graph with the optimization objective of minimizing the sum of weights on the path;

[0130] In the embodiments of this application, the target path sequence refers to an ordered set of nodes in a directed acyclic graph, traversed from the starting node representing the current state to the ending node representing the final capability goal. The optimization objective is to minimize the total execution time of all tasks in this sequence, i.e., to find the "fastest path to achieve the goal". This step is particularly applicable to scenarios where there are parallel mutually exclusive branches in the graph (e.g., achieving the same goal can be achieved by choosing either technical solution A or technical solution B).

[0131] In some embodiments of this application, the system initializes the distance from all nodes to the starting node to infinity, and the distance to the starting node to 0. Utilizing the greedy strategy of Dijkstra's algorithm, the system maintains a priority queue, and each time selects the node with the smallest current cumulative weight value for relaxation, updating the cumulative weight values ​​of its neighboring nodes. Since it is a directed acyclic graph, this algorithm guarantees convergence within a finite number of steps. Finally, the system constructs an optimal path with the shortest total time by backtracking the recorded predecessor nodes. This path represents the execution plan that allows the user to achieve their goal fastest while satisfying all logical dependencies.

[0132] S604. Based on the target path sequence, generate a target task chain for the target object identifier.

[0133] In some embodiments of this application, the system extracts the task identifiers of all nodes in the target path sequence and arranges them into a linked list structure according to their topological order in the path. The system can also attach the estimated execution time to each task node to generate a project schedule with estimated time progress. For other branch nodes not selected in the target path sequence, the system marks them as "optional supplementary tasks" and does not treat them as core deliverables, thereby focusing the user's execution efforts.

[0134] As can be seen, this application's embodiments introduce a time dimension as the core cost function and utilize the shortest path algorithm to automatically search for the optimal solution in complex task dependency networks, achieving task chain construction oriented towards time efficiency. This scheme can automatically plan the execution path with the shortest total time and highest efficiency when multiple technical routes or execution branches exist, reducing users' time costs and maximizing execution benefits.

[0135] In some embodiments of this application, after generating a target task chain for a target object identifier based on the target task unit, the method further includes:

[0136] S701, Receive execution feedback data for the current task execution node in the target task chain, the execution feedback data including the task execution completion score;

[0137] In the embodiments of this application, the current task execution node refers to the task unit that the target object is processing or has just submitted a completion result in the target task chain. Execution feedback data is a data packet transmitted back to the server through the user terminal or automated evaluation system, used to characterize the specific situation of the task execution. The task execution completion score is a quantitative indicator of the quality of the execution result, usually a standardized value (such as 0 to 100 points or a coefficient of 0 to 1.0).

[0138] In some embodiments of this application, when the current task is a programming code task, the system runs the submitted code in a backend sandbox environment and calculates the task completion score based on the pass rate of the test cases; when the current task is a knowledge question-and-answer task, the system directly generates a score based on the accuracy rate. This data reflects the target object's mastery of the current knowledge point in real time, providing an objective basis for the dynamic adjustment of subsequent links.

[0139] S702. Based on the task completion score, perform task execution node insertion or deletion processing on the target task chain.

[0140] In the embodiments of this application, this step aims to construct a closed-loop adaptive adjustment logic that dynamically corrects the pre-generated static plan based on real-time capability feedback, so as to make the target task chain more accurate and more timely.

[0141] As can be seen, this application's embodiment achieves adaptive matching of the task chain to the user's actual capabilities by introducing dynamic link reconstruction logic based on real-time feedback. This scheme can automatically insert tutoring tasks to reduce the gradient when the user performs poorly, and automatically remove redundant tasks to improve efficiency when the user performs well, thereby transforming a static plan into a dynamic, personalized guidance path, ensuring the smoothness and efficiency of the execution process.

[0142] In some embodiments of this application, based on the task completion score, the target task chain is subjected to task execution node insertion or deletion processing, including at least one of the following steps:

[0143] S801. If the execution completion score is less than the preset first threshold, obtain the task unit to be supplemented that matches the current task execution node in the task unit library, and perform task execution node insertion processing on the target task chain based on the task unit to be supplemented.

[0144] In the embodiments of this application, the first threshold is a critical value (e.g., 60 points or the passing grade) for determining whether the target object has passed the current assessment or reached the minimum mastery requirement. The supplementary task unit refers to a backup task entity used for remedial teaching, basic reinforcement, or fine-grained breakdown of currently unmastered content.

[0145] In some embodiments of this application, a remedial strategy is triggered when the system detects that the score is below a first threshold. The system first analyzes the knowledge point tags associated with the current task execution node, then retrieves task units with the same knowledge point tags but lower difficulty levels from the task unit library; or retrieves basic concept task units that have a "prerequisite dependency" relationship with the current task. The system inserts one or more retrieved task units into the target task chain immediately following the current node in a logically progressive order, and updates the pointer connections between nodes in the chain. This process ensures that when the target object fails to pass the current level, it does not mechanically repeat the same task, but instead strengthens its foundation through lower-level auxiliary tasks, preventing task chain blockage caused by excessive difficulty differences.

[0146] In the embodiments of this application, a multi-dimensional knowledge graph is constructed at the bottom layer of the task unit library. The entities in this graph include not only task units but also "knowledge points." Entities are connected by semantic edges such as "Contains," "Precedes," and "Is-A." The specific retrieval logic is as follows: when insertion is required, the system first locates the "Identity (ID)" attached to the current task execution node; then, it traverses the graph along the reverse path of the "Is-A" edge (i.e., towards materialization or foundation) or along the reverse path of the "Precedes" edge (i.e., towards prior knowledge). For example, if the current task is associated with the knowledge point "doubly linked list reversal," the system queries the graph to find its prior knowledge points as "singly linked list traversal" and "pointer basics." The system then retrieves all Level-1 tasks under the "Pointer Basics" knowledge point, sorts them according to user preferences (e.g., prioritizing video or practical tasks), and selects the top-ranked task as the supplementary task unit. This graph-based retrieval method ensures the logical relevance and effectiveness of the remedial tasks to the current obstacle.

[0147] S802. If the completion score is greater than the preset second threshold, in the target task chain, determine the task execution node to be skipped that is located after the current task execution node and whose task difficulty level is less than the preset level threshold. Based on the task execution node to be skipped, perform task execution node deletion processing on the target task chain. The second threshold is greater than or equal to the first threshold.

[0148] In the embodiments of this application, the second threshold is a high standard value (e.g., 90 points or the excellent line) for determining whether the target object has perfectly mastered or exceeded the current task. Task execution nodes to be skipped refer to low-value tasks in the originally planned subsequent path that are too simple, repetitive, or ineffective for the target object who has already demonstrated a high level of ability. The preset level threshold is usually set based on the difficulty level of the currently completed tasks (e.g., if the currently completed task is at difficulty level 5, then subsequent tasks at difficulty level 3 and below can be considered low-level).

[0149] In some embodiments of this application, when the completion score indicates that the target object has perfectly mastered or exceeded the current task, the system traverses the subsequent nodes in the target task chain that have not yet been executed. The system reads the difficulty attribute of each subsequent node and marks those nodes involving the same or subordinate knowledge points and whose difficulty is significantly lower than the currently completed task as task execution nodes to be skipped. Subsequently, the system performs a deletion operation, removing these nodes from the linked list structure and directly pointing the predecessor node of the deleted node to its successor node. This step accelerates and optimizes the execution path by dynamically pruning inefficient repetitive practice.

[0150] As can be seen, this embodiment of the application automatically inserts downgrade tutoring tasks when scores are low and automatically removes low-level redundant tasks when scores are high. This scheme enables the task chain to scale and adapt according to the user's real-time performance. This not only effectively solves the problem of users experiencing lag due to weak foundations, but also avoids the time wasted by high-level users due to repetitive low-difficulty practice, maximizing the output of ability improvement per unit of time.

[0151] In some embodiments of this application, matching corresponding target task units from a preset task unit library based on a skill requirement feature map includes:

[0152] S901. For each target graph node in the skill requirement feature graph, construct a task candidate set based on the intersection operation of knowledge point labels;

[0153] In embodiments of this application, a target graph node is defined as a skill atom, which is the smallest indivisible semantic unit of capability parsed from an external demand data stream (e.g., "Python list comprehension" rather than the general "Python programming"). Knowledge point tags are standardized terms pre-annotated in the task unit metadata, used to characterize the specific technical theories or operational points covered by the task.

[0154] In some embodiments of this application, the system employs an inverted index technique to perform intersection operations. The system pre-constructs an index structure with knowledge point tags as keys and task unit identifier lists as values. When processing a target graph node, the system extracts the set of knowledge points contained in that node, retrieves all task units with non-empty intersections with it from the index structure, and adds them to the task candidate set. This step, through intersection logic in set theory, filters out tasks with extremely low relevance before performing complex weight calculations, reducing the search space for subsequent calculations and lowering the system load.

[0155] S902. Construct a weighted bipartite graph connecting the target graph nodes with each task unit in the task candidate set;

[0156] In the embodiments of this application, a weighted bipartite graph is a special graph structure in which the set of nodes is divided into two disjoint subsets: the first subset contains all target graph nodes (i.e., the demand side), and the second subset contains all preset task units (i.e., the supply side) in the task candidate set. Edges in the graph exist only between the first and second subsets; there are no connections within the subsets themselves. In the step of constructing the weighted bipartite graph, the matching score from the above embodiments can be assigned to the corresponding edge connecting nodes in the first and second subsets.

[0157] S903. Solve the weighted bipartite graph using a preset matching algorithm, determine the target task matching relationship, and identify the matched task unit as the target task unit.

[0158] In the embodiments of this application, the preset matching algorithm refers to a graph optimization algorithm that maximizes the sum of the weights of the selected edges under certain constraints, such as a variant of the Kuhn-Munkres Algorithm (KM) or the Minimum Cost Maximum Flow Algorithm.

[0159] In some embodiments of this application, the system runs the KM algorithm with the global optimization objective of maximizing the sum of the weights of all matching edges. This algorithm, by introducing a labeling mechanism, finds a complete or optimal match in polynomial time. Compared to simple Top-K sorting, weighted bipartite graph matching can solve the problems of "resource competition" and "global optimum." For example, when a high-value task can train both skill A and skill B, but can only occur once in the current path planning, the algorithm can allocate it to the side with the greater benefit based on its global weight contribution, or select a set of highly complementary task combinations to cover all skill atoms, avoiding suboptimal overall efficiency caused by local greed. The system ultimately determines the set of task units pointed to by the matching edges output by the algorithm as the target task unit.

[0160] As can be seen, the embodiments of this application introduce a candidate set pre-screening mechanism based on inverted index and a global matching algorithm based on weighted bipartite graph. The pre-screening eliminates irrelevant tasks to improve computational performance, and the bipartite graph matching algorithm optimizes the correspondence between skills and tasks in the global dimension. By maximizing the overall matching weight, the suboptimal resource allocation problem that may be caused by local greedy strategies is solved, and the mathematically optimal solution of the constructed task chain in terms of teaching effectiveness and knowledge coverage is achieved.

[0161] In some embodiments of this application, determining the number of target tasks based on the demand weight values ​​of target graph nodes includes:

[0162] S1001. Based on the required weight values ​​of the target map nodes, determine the preset mastery confidence threshold of the target map nodes through a nonlinear mapping function;

[0163] In the embodiments of this application, the preset mastery confidence threshold refers to the minimum probability value required for the system to determine that the target object has reached a level of mastery of the skill or knowledge point represented by the node that meets market expectations, and the value range is usually [0, 1]. This preset mastery confidence threshold is non-linearly positively correlated with the demand weight value.

[0164] In some embodiments of this application, the system employs a variant of the Sigmoid function as the nonlinear mapping function. The system sets a base confidence level (e.g., 0.5), and as the demand weight value increases, the preset mastery confidence threshold grows in an "S"-shaped curve, approaching 1.0. For example, for core high-frequency test points with a demand weight value of 0.9, the system-calculated confidence threshold might be 0.98 (i.e., mastery is required); while for peripheral knowledge points with a demand weight value of 0.3, the confidence threshold might only be 0.60 (i.e., basic understanding is required). This mapping logic reflects a differentiated configuration strategy of "high-value skills require high-precision mastery, while low-value skills only require general knowledge."

[0165] S1002. Obtain the knowledge complexity coefficient of the target graph node, and calculate the total value of the target training impulse based on the preset mastery confidence threshold and knowledge complexity coefficient.

[0166] In embodiments of this application, the knowledge complexity coefficient is a quantitative indicator pre-stored in the graph metadata, used to characterize the amount of cognitive resources required to master the knowledge point (e.g., the coefficient for mastering "loop structure" is 1.2, and the coefficient for mastering "dynamic programming algorithm" is 5.0). The target training impulse total value refers to the total amount of task stimuli theoretically required to overcome the cognitive resistance of the knowledge point and reach the preset mastery confidence level.

[0167] In some embodiments of this application, the formula for calculating the total target training impulse is: I target =C k ×ln(P thresh / (1-P thresh Among them, It arget C represents the total training impulse value. k Let P be the knowledge complexity coefficient. threshThis is to preset the confidence threshold. The formula is based on the inverse operation of the logistic model in Item Response Theory (IRT), which means that as the target confidence increases, the required training impulse will increase exponentially, rather than simply linearly.

[0168] S1003. Obtain the average effective cognitive gain value of candidate task units in the task unit library, divide the total target training impulse value by the average effective cognitive gain value, and round up to obtain the number of target tasks.

[0169] In the embodiments of this application, the average effective cognitive gain value refers to the average increase in capability or contribution to the target object that a single standard task unit can bring after execution. This value is derived by the system based on Bayesian inference using historical big data.

[0170] In some embodiments of this application, the system first selects the top N (TOP-N) candidate tasks for the target map node from the library and calculates the historical average gain of these tasks. Then, a division operation is performed: Q = ⌈Itarget / (G avg ×δ)⌉。 Where Q is the number of target tasks, ⌈⌉ represents the floor function, and G avg The average effective cognitive gain value is represented by δ, which is a redundancy safety factor (e.g., 1.2, used to offset the forgetting curve effect). Through this step, the system transforms the abstract "weight" into a scientifically calculated specific "number of practice questions" or "number of project exercises," avoiding the problems of insufficient mastery due to too few tasks or diminishing marginal utility due to too many tasks.

[0171] As can be seen, the embodiments of this application propose a quantitative model based on dual constraints of cognitive load and mastery confidence. By determining differentiated mastery standards through nonlinear mapping, the required physical training impulse is calculated in combination with the complexity of the knowledge points themselves, and finally converted into a specific number of tasks. This achieves a balance between the task volume and "market value" and "learning cost," ensuring that core difficulties have sufficient training support, while simple knowledge points do not consume too much time and resources.

[0172] Secondly, embodiments of this application provide a task chain construction system for a skills training platform, which is used to execute the task chain construction method for a skills training platform as described in any of the above embodiments.

[0173] Thirdly, embodiments of this application provide a computer-readable storage medium storing a computer program configured to be executed by a processor to implement the task chain construction method for a skills training platform as described in any of the above embodiments.

[0174] The embodiments of this application have been described in detail above. Specific examples have been used to illustrate the principles and implementation methods of this application. The description of the above embodiments is only for the purpose of helping to understand the method and core ideas of this application. At the same time, for those skilled in the art, there will be changes in the specific implementation methods and application scope based on the ideas of this application. Therefore, the content of this specification should not be construed as a limitation of this application.

Claims

1. A method for constructing task chains for a skills training platform, characterized in that, The task chain construction method for the skills training platform includes: Obtain the external demand data stream associated with the target object identifier in the skills training platform. The external demand data stream includes multiple skill demand description texts with time sequence markers. The external demand data stream is subjected to entity extraction processing to obtain multiple skill demand feature entities; Based on the frequency of occurrence of the skill requirement feature entity in the external requirement data stream and the time sequence marker, determine the requirement weight value of each skill requirement feature entity; The skill demand feature entity is used as a graph node, and the demand weight value is written into the attribute parameters of the corresponding graph node to obtain a skill demand feature graph. Based on the skill requirement feature map, the corresponding target task unit is matched from the preset task unit library; Based on the target task unit, a target task chain is generated targeting the target object identifier; The step of matching corresponding target task units from a preset task unit library based on the skill requirement feature map includes: identifying target map nodes in the skill requirement feature map; for each preset task unit in the task unit library, determining the content coverage index, difficulty gradient matching degree, and historical contribution effectiveness coefficient between the preset task unit and the target map node; determining a matching score between the preset task unit and the target map node based on the content coverage index, the difficulty gradient matching degree, and the historical contribution effectiveness coefficient; determining the number of target tasks based on the requirement weight value of the target map node; and determining the target task units matching the number of target tasks from the task unit library according to the matching score. The step of determining the target task units matching the target task quantity from the task unit library based on the matching score includes: determining a preset mastery confidence threshold for the target graph node using a nonlinear mapping function based on the demand weight value of the target graph node; obtaining the knowledge complexity coefficient of the target graph node, and calculating the total target training momentum based on the preset mastery confidence threshold and the knowledge complexity coefficient; obtaining the average effective cognitive gain value of the candidate task units in the task unit library, dividing the total target training momentum by the average effective cognitive gain value, and rounding up to obtain the target task quantity.

2. The task chain construction method for a skills training platform as described in claim 1, characterized in that, The step of determining the demand weight value of each skill demand feature entity based on the frequency of occurrence of the skill demand feature entity in the external demand data stream and the time sequence marker includes: Determine the time difference between the timing marker and the current system time; Based on the time difference, determine the time decay coefficient of the corresponding skill requirement feature entity; Based on the time decay coefficient and the frequency of occurrence, the demand weight value of the corresponding skill demand feature entity is determined.

3. The task chain construction method for a skills training platform as described in claim 1, characterized in that, The step of generating a target task chain for the target object identifier based on the target task unit includes: Construct a directed acyclic graph including the target task units; Obtain historical execution log data of the target object identifier, wherein the historical execution log data includes historically completed tasks; Based on the completed tasks in the history, the directed acyclic graph is pruned to obtain a processed directed acyclic graph. Based on the processed directed acyclic graph, a target task chain is generated for the target object identifier.

4. The task chain construction method for a skills training platform as described in claim 3, characterized in that, The step of generating a target task chain for the target object identifier based on the processed directed acyclic graph includes: Obtain the estimated execution time for each node in the processed directed acyclic graph; The estimated execution time is mapped to the weight value of the corresponding node in the directed acyclic graph; With the goal of minimizing the sum of weights on the path, Dijkstra's algorithm is used to determine the target path sequence from the start node to the end node in the directed acyclic graph. Based on the target path sequence, a target task chain is generated targeting the target object identifier.

5. The task chain construction method for a skills training platform as described in claim 1, characterized in that, After generating the target task chain for the target object identifier based on the target task unit, the method further includes: Receive execution feedback data for the current task execution node in the target task chain, the execution feedback data including a task execution completion score; Based on the task completion score, the target task chain is processed by inserting or deleting task execution nodes.

6. The task chain construction method for a skills training platform as described in claim 5, characterized in that, The step of inserting or deleting task execution nodes in the target task chain based on the task completion score includes at least one of the following steps: If the execution completion score is less than a preset first threshold, obtain the task unit to be supplemented that matches the current task execution node from the task unit library, and perform task execution node insertion processing on the target task chain based on the task unit to be supplemented. If the execution completion score is greater than a preset second threshold, in the target task chain, a task execution node to be skipped is determined that is located after the current task execution node and has a task difficulty level less than a preset level threshold. Based on the task execution node to be skipped, the target task chain is deleted. The second threshold is greater than or equal to the first threshold.

7. A task chain construction system for a skills training platform, characterized in that, The task chain construction system for the skills training platform is used to execute the task chain construction method for the skills training platform as described in any one of claims 1 to 6.

8. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores a computer program configured to be executed by a processor to implement the task chain construction method for a skills training platform as described in any one of claims 1 to 6.

Images