A multi-task automated question setting method and system

Abstract

The present application belongs to the cross technical field of artificial intelligence and cognitive assessment, and discloses a multi-task automatic question setting method and system. The core method comprises: collecting real-time behavior data of user multi-task operation, extracting standardized features after cleaning; constructing a cognitive task feature map and establishing a task relationship model through node embedding; dynamically calculating individual thread capacity threshold based on behavior data, generating personalized resource allocation parameters; injecting capacity parameters into the map to predict cognitive conflict intensity indicators; screening safe task combinations according to the conflict intensity, arranging the time axis and balancing the difficulty to generate test instruction set; executing the instruction set and establishing a feedback link to realize data closed-loop update. The present application breaks through the cognitive resource adaptation limitation of traditional static question setting, realizes the accurate generation of multi-task combination in high-risk professional complex scene through dynamic capacity modeling and conflict prediction technology, and greatly improves the work performance prediction validity and system adaptive ability.

Description

TECHNICAL FIELD

[0001] The present application belongs to the cross technical field of artificial intelligence and cognitive psychology, and particularly relates to a multi-task automatic question setting method and system. BACKGROUND

[0002] The work performance prediction of special occupations such as pilots has always been a very important problem. Due to the high-risk type and complexity of real work, people try to select suitable personnel to perform tasks through cognitive ability tests. In the field of psychology, there are many classic paradigms for tests of cognitive abilities such as attention and working memory. However, due to the complex multi-task scenarios faced by real work, the predictive ability of these classic tests for work performance is very low. On this basis, the general solution is to measure all aspects of a single individual, that is, to continuously complete various types of cognitive tests, which usually relies on a static task allocation method, that is, experts select good questions according to experience and carry out tests, and do not fully consider individual differences in the execution of multi-task scenarios. At the same time, there is also a lack of a scientific framework to guide how to convert theoretical multi-task processing ability into task design in practical applications. Defects in the prior art analysis:

[0003] (1) Static question setting limitations. Traditional cognitive ability tests (such as N-back working memory tests and Stroop attention tests) rely on expert experience to statically combine tasks, and cannot dynamically adapt to fluctuations in individual cognitive resources. For example, in pilot selection, the predictive validity of static tests for actual flight performance is generally low.

[0004] (2) Lack of resource competition modeling. Existing graph neural network (GNN) task modeling methods only consider task similarity and do not quantify cognitive resource conflicts:

[0005] Ignoring the directional competition of attention, working memory, and executive control resources;

[0006] Unable to simulate the timing resource preemption caused by task interruption / switching;

[0007] Leading to high deviation of the generated task combination from real work scenarios.

[0008] (3) Insufficient adaptability to individual differences. Mainstream adaptive tests (such as CAT systems) only adjust single-task difficulty and do not solve the individualization problem in multi-task concurrent scenarios:

[0009] Thread capacity threshold is fixed and does not combine real-time behavior data (response delay / error rate) for dynamic calibration;

[0010] Lack of individualized modeling tools such as "cognitive resource decay curve";

[0011] This results in a higher mismatch rate for high cognitive load task combinations. Summary of the Invention

[0012] The present invention provides a multi-task automated question matching method and system to solve the problem of how to generate a multi-task test combination that conforms to real work scenarios based on the dynamic parameters of individual cognitive thread capacity and task feature maps by integrating resource competition intensity prediction and timing conflict analysis.

[0013] In order to solve the above technical problems, the present invention provides a multi-task automated question matching method, comprising:

[0014] Collect real-time behavioral data from multi-task tests, perform data cleaning and feature extraction, and obtain standardized behavioral data;

[0015] Construct a cognitive task feature map, perform node embedding and relationship modeling, and obtain an initial cognitive map;

[0016] Dynamically calculate thread capacity thresholds based on standardized behavior data, perform personalized resource allocation modeling, and obtain dynamic thread capacity parameters;

[0017] The dynamic thread capacity parameter and the initial cognitive map are integrated to predict cognitive conflict and generate a conflict intensity index. The expression for predicting cognitive conflict is:

[0018]

[0019] in, For the The message vector of the layer; is the activation function; is the neighbor set of node i; is a two-dimensional rotation matrix; is the angle between resource demand vectors; is the connectivity of node i;

[0020] Furthermore, the node state update equation is:

[0021]

[0022] in, is the state vector of node i in layer l; is the historical state vector of node i in the l−1th layer; For the The message vector of the layer; is the global attribute node vector; represents Hadamard product (element-wise multiplication), GRU is gated recurrent unit;

[0023] The expression for generating the conflict intensity index is:

[0024]

[0025] wherein, is the final conflict intensity index; is the Shannon entropy conflict measure; is the capacity confidence coefficient; is the timing conflict weight coefficient; is the task switching time variance; is the task type coefficient;

[0026] screening safe task combinations according to the conflict intensity index, optimizing multi-task sequences, and generating multi-task test instruction sets;

[0027] executing the multi-task test instruction set and establishing a real-time feedback link to perform dynamic data collection and model updating.

[0028] Further, collecting real-time behavior data in the multi-task test includes:

[0029] collecting multi-task operation logs of the user during the test execution process to obtain response delay data and error rate data;

[0030] performing time series alignment processing on the response delay data and the error rate data to generate a timestamp-synchronized behavior sequence;

[0031] extracting task switching delay features and concurrent error features from the behavior sequence to perform data cleaning and feature extraction to obtain standardized behavior data.

[0032] Further, constructing a cognitive task feature map includes:

[0033] extracting operation type features, resource demand features, and difficulty level features of the tasks from a preset cognitive task library;

[0034] encoding the operation type features, resource demand features, and difficulty level features as graph node attributes;

[0035] constructing edge connections based on the cognitive ability overlap relationship between tasks, performing node embedding and relationship modeling, and obtaining an initial cognitive map.

[0036] Further, dynamically calculating thread capacity thresholds includes:

[0037] obtaining standardized behavior data, calculating error rate change gradients and switching delay increments during task concurrency;

[0038] fitting individual cognitive resource decay curves according to the error rate change gradients and the switching delay increments;

[0039] The maximum number of threads that can be maintained is determined based on a cognitive resource decay curve, personalized resource allocation modeling is performed, and a dynamic thread capacity parameter is obtained.

[0040] Further, the cognitive conflict prediction comprises:

[0041] The dynamic thread capacity parameter is injected into a global attribute node of an initial cognitive graph;

[0042] The injected cognitive graph is subjected to multiple rounds of message passing using a graph neural network to predict the cognitive resource competition intensity of the task combination;

[0043] A conflict intensity index is output according to the cognitive resource competition intensity, and the conflict intensity index is generated.

[0044] Further, the screening of the safe task combination comprises:

[0045] The conflict intensity index is obtained, and the task combination whose conflict intensity exceeds a preset threshold is filtered to obtain a safe task combination set;

[0046] Multiple task combinations, task switching combinations, and task interruption combinations are selected from the safe task combination set.

[0047] Further, generating the multi-task test instruction set comprises:

[0048] The multiple task combinations, the task switching combinations, and the task interruption combinations are arranged on a time axis and balanced in difficulty to generate the multi-task test instruction set.

[0049] Further, executing the multi-task test instruction set comprises:

[0050] The multi-task test instruction set is loaded, and the sequence of concurrent tasks, switching tasks, and interruption tasks is executed in a test engine;

[0051] Real-time operation behavior of a user during execution is recorded, and a real-time feedback link is established.

[0052] Further, dynamic data acquisition and model updating comprise:

[0053] The real-time operation behavior is input to a standardized behavior data acquisition process for dynamic data acquisition and model updating.

[0054] A multi-task automated question setting system for implementing any of the above methods comprises:

[0055] A real-time behavior acquisition module acquires real-time behavior data in a multi-task test, performs data cleaning and feature extraction, and obtains standardized behavior data;

[0056] A cognitive graph construction module is configured to construct a cognitive task feature graph, perform node embedding and relationship modeling, and obtain an initial cognitive graph;

[0057] A thread capacity modeling module is configured to dynamically calculate a thread capacity threshold based on standardized behavior data, perform personalized resource allocation modeling, and obtain dynamic thread capacity parameters;

[0058] A conflict prediction module is configured to perform cognitive conflict prediction by fusing the dynamic thread capacity parameters and the initial cognitive graph, and generate a conflict intensity index;

[0059] A task optimization module is configured to filter a safe task combination according to the conflict intensity index, perform multi-task sequence optimization, and generate a multi-task test instruction set;

[0060] A test execution and feedback module is configured to execute the multi-task test instruction set, establish a real-time feedback link, and perform dynamic data collection and model updating.

[0061] The key innovations of the application include:

[0062] (1) The cognitive thread theory is converted into a calculable capacity parameter, and the real-time quantification of individual cognitive ability is realized through resource decay curve modeling, providing a scientific basis for personalized item allocation.

[0063] (2) A global attribute node and virtual edge connection mechanism is developed, which breaks through the embedding of dynamic capacity parameters into task relationship graphs, and solves the structured fusion problem of cognitive resource constraints and task features.

[0064] (3) A graph convolution model based on Riemannian manifold is proposed, which analyzes the directional competition characteristics of cognitive resources through a rotation matrix, and solves the quantitative prediction bottleneck of resource preemption in a multi-task environment.

[0065] The main beneficial effects are as follows:

[0066] (1) By quantifying individual real-time cognitive ability as thread capacity parameters and fusing the global constraints of task feature graphs, the system realizes accurate matching of multi-task combinations and individual cognitive resources. Compared with static item allocation methods, the problem of low test validity caused by ignoring cognitive resource fluctuations is completely solved, and the generated task combination can truly reflect the current cognitive state of the user.

[0067] (2) The directional competition relationship of three types of resources, attention, working memory and executive control, is analyzed using graph embedding technology, and the directional conflict simulation on Riemannian manifold is combined to solve the problem of quantitative multi-task resource preemption that traditional methods cannot solve. The generated task combination avoids cognitive overload and significantly reduces the operational risk in high-risk work scenarios.

[0068] (3) Through the timing conflict analysis, the dynamic characteristics such as task switching delay and interruption recovery are integrated, so that the generated test combination accurately simulates the timing pressure of the real work scene. Compared with the traditional scheme, the reliability of work performance prediction is greatly improved, and it is especially suitable for special occupations such as pilots who need to cope with unexpected situations. BRIEF DESCRIPTION OF DRAWINGS

[0069] Figure 1 A flowchart of a multi-task automatic test allocation method provided by an embodiment of the present application is provided.

[0070] Figure 2 A structural block diagram of a multi-task automatic test allocation system provided by an embodiment of the present application is provided. DETAILED DESCRIPTION

[0071] Embodiment one: reference Figure 1 A flowchart of a multi-task automatic test allocation method provided by an embodiment of the present application is provided. The flowchart can at least include steps S100-S600:

[0072] S100, collect real-time behavior data in multi-task tests, perform data cleaning and feature extraction, and obtain standardized behavior data;

[0073] S200, construct a cognitive task feature map, perform node embedding and relationship modeling, and obtain an initial cognitive map;

[0074] S300, dynamically calculate thread capacity threshold based on standardized behavior data, perform personalized resource allocation modeling, and obtain dynamic thread capacity parameters;

[0075] S400, fuse dynamic thread capacity parameters and initial cognitive map to predict cognitive conflict, and generate conflict intensity index;

[0076] S500, screen safe task combinations according to the conflict intensity index, perform multi-task sequence optimization, and generate a multi-task test instruction set;

[0077] S600, execute the multi-task test instruction set and establish a real-time feedback link, perform dynamic data collection and model updating.

[0078] Step S100 at least includes steps S110-S130:

[0079] S110, collect multi-task operation logs and real-time behavior data of the user during test execution, and obtain response delay data and error rate data.

[0080] During the test execution, the system captures the multi-task operation log and real-time behavior data of the user in real time through the embedded data collection module. Specifically, the embedded data collection module is integrated in the event scheduling layer of the test engine, and adopts an event-driven architecture to listen to user interaction events. When the user starts to perform a multi-task combination, the system records the task start timestamp; when the user performs a task switching operation, the system captures the previous task termination time and the next task start time; when a task interruption event is triggered, the system marks the interruption time and the recovery time. For each task instance, the system collects two types of core data: response delay data, i.e. the time interval from the presentation of the task instruction to the user's effective response, accurate to the millisecond level; error rate data, i.e. the deviation rate of the user's operation result from the standard answer, which is calculated and counted according to the task type.

[0081] The response delay data includes simple reaction time data, selection reaction time data and complex decision time data, corresponding to different cognitive processing levels respectively.

[0082] The error rate data covers three types of operation error rate, judgment error rate and logic error rate, each of which is classified and marked by an error type coding table.

[0083] The multi-task operation log is stored in JSON format, containing six fields of task ID, task type, start time, end time, response time and operation result.

[0084] The real-time behavior data is transmitted to the data processing center in real time through the WebSocket protocol to form an original behavior data set.

[0085] The original behavior data set serves as the input source for time series alignment processing.

[0086] S120, the response delay data and the error rate data are subjected to time series alignment processing to generate a timestamp-synchronized behavior sequence.

[0087] The system receives the original behavior data set from S110, and first carries out time reference unification processing. Specifically, the network time protocol is used to synchronize the system clock of all data acquisition terminals, eliminating the clock deviation between devices. For the response delay data and error rate data, a double-channel time axis mapping mechanism is established: the response delay channel takes the task presentation moment as the time origin, and the error rate channel takes the user operation submission moment as the time origin. Through the time axis normalization algorithm, the data of the two channels are mapped to a unified time reference axis, eliminating the timing deviation. Further, the dynamic time warping technology is used to align the timing data of different types of tasks: for multiple task data, a 500 millisecond fixed window is used for segmentation and aggregation; for task switching data, an adaptive window based on event triggering is used, and the window size is dynamically adjusted according to the duration of the previous task; for task interruption data, a fixed window of 800 milliseconds is set to cover the 400 milliseconds interval before and after the interruption. In the time axis alignment process, the system attaches an accurate timestamp to each data point, and the timestamp format is Unix millisecond timestamp.

[0088] In the timestamp-synchronized behavior sequence, each data unit contains five attributes: standardized timestamp, task type code, response delay value, error rate value and task state flag.

[0089] The task state flag is used to mark three states: normal execution, task switching and task interruption.

[0090] The behavior sequence is stored in a timing database, with a time synchronization accuracy of ±5 milliseconds, ensuring the timing consistency of subsequent feature extraction.

[0091] The timestamp-synchronized behavior sequence serves as the input data source of the feature extraction module.

[0092] S130, task switching delay features and concurrent error features are extracted from the behavior sequence, data cleaning and feature extraction are carried out, and standardized behavior data are obtained.

[0093] The system receives the timestamp synchronization behavior sequence from S120, and first performs a data cleaning process. Specifically, a three-stage outlier processing mechanism is adopted: in the first stage, based on the interquartile range method, data points with response delays less than 0.5 times the first quartile or greater than 1.5 times the third quartile are removed; in the second stage, based on the task type baseline, data points exceeding the historical maximum delay value of the same type of task are filtered; in the third stage, based on the dynamic threshold, data points deviating from the moving average by three times the standard deviation of the three consecutive sampling points are removed. During the data cleaning process, the system maintains an abnormal data log to record the original information and the reason for the removed data. After completing the data cleaning, the system performs feature extraction operations: for the task switching delay feature, the response time difference within a 200 millisecond window before and after the task switching point is calculated, and four features including switching delay mean, switching delay variance, maximum switching delay and switching delay change gradient are extracted; for the concurrency error feature, the operation sequence during the execution of multiple tasks is analyzed, and three features including concurrency error density, cross-task error correlation and error propagation intensity are extracted. The feature extraction adopts a sliding window statistical method, and the window size is consistent with S120: a 500 millisecond window is used for multiple task segments, a 300 millisecond window is used for task switching points, and an 800 millisecond window is used for task interruption zones. All feature extraction algorithms are implemented through a feature calculation engine, which uses a streaming processing architecture to process behavior sequence data in real time. The feature data is converted through Z-score standardization to conform to the standard normal distribution with a mean of 0 and a standard deviation of 1. The standardized behavior data contains a seven-dimensional feature vector: switching delay mean, switching delay variance, maximum switching delay, switching delay change gradient, concurrency error density, cross-task error correlation, and error propagation intensity. The standardized behavior data is stored in the feature warehouse and simultaneously serves as the input of two downstream modules: one is input to the S300 dynamic thread capacity evaluation module for calculating the thread capacity threshold; the other is input to the S210 cognitive map construction module as a task feature supplement. The standardized behavior data is pushed to the downstream processing module in real time through the message queue, forming a closed-loop data processing link.

[0094] Step S200 includes at least steps S210-S230:

[0095] S210, extracting the operation type feature, resource requirement feature and difficulty level feature of the task from the preset cognitive task library.

[0096] The system accesses a preset cognitive task library and obtains three-dimensional feature data of the task through a feature extraction engine. Specifically, the preset cognitive task library is stored in a distributed graph database and contains definition files of multiple cognitive tasks. For operation type features, the system adopts a rule-based feature mapping algorithm: reading the task description text, matching a predefined keyword table (such as "orientation recognition" mapped to navigation type and "radio interaction" mapped to communication type), and outputting discrete operation type codes. For resource demand features, the system adopts a five-level quantitative scale: by analyzing the cognitive load description in the task design document, "low attention demand" is quantified as level 1 and "high working memory demand" is quantified as level 5 to form a resource demand vector. For difficulty level features, the system adopts an adaptive difficulty calibration algorithm: combining task historical completion rate and error distribution data, a continuous difficulty value with 0.1 precision is generated based on preset primary / intermediate / advanced levels. In the feature extraction process, the system receives standardized behavior data from S130 as supplementary input, integrates task switching delay variance and concurrent error density features into the resource demand evaluation model, and enhances individual adaptability of feature representation. The feature extraction engine outputs a structured feature dataset containing three-tuple features of each task: operation type code, resource demand vector, and difficulty level value.

[0097] S220, encode operation type features, resource demand features, and difficulty level features as graph node attributes.

[0098] The system receives the structured feature dataset generated by S210 and performs feature vectorization conversion through a node encoder. Specifically, a hierarchical encoding architecture is adopted: the first layer performs one-hot encoding on operation type features to generate an 8-dimensional sparse vector; the second layer performs vector normalization on resource demand features to convert attention / working memory / executive control values of the five-level scale into a three-dimensional continuous vector in the [0, 1] interval; the third layer performs segmented encoding on difficulty level features, with primary difficulty mapped to the [0.2, 0.4] interval vector, intermediate difficulty mapped to the [0.5, 0.7] interval vector, and advanced difficulty mapped to the [0.8, 1.0] interval vector. The node encoder uses feature fusion technology to concatenate the three types of encoded feature vectors into a 12-dimensional node attribute vector (8-dimensional operation type + 3-dimensional resource demand + 1-dimensional difficulty level). During encoding, the system establishes a feature-node mapping table to ensure that each task node has a unique attribute vector identifier. The node attribute vector is reduced to 5 dimensions through principal component analysis, retaining 95% of the feature variance and reducing the complexity of subsequent graph calculations. The encoded node attributes are stored in a graph structure storage area, with each node containing a task ID and attribute vector pair, providing standardized input for graph construction. The node attribute dataset also serves as input for S230 edge connection construction, ensuring consistency between node relationship modeling and attribute features.

[0099] S230, based on the cognitive ability overlap relationship between tasks, edge connection is constructed, node embedding and relationship modeling are performed, and an initial cognitive graph is obtained.

[0100] The system receives the node attribute dataset generated in S220, and creates a cognitive task feature graph through a graph construction engine. Specifically, an edge connection strategy based on cognitive ability overlap is adopted: first, the resource requirement similarity between task nodes is calculated, the cosine similarity algorithm is used to compare the resource requirement vectors, and strong connection edges are established between nodes with a similarity greater than 0.7; second, the operation type complementarity is detected, and weak connection edges are established between operation types that need to be used alternately (such as navigation and communication); finally, the difficulty progression relationship is introduced, and hierarchical connection chains are formed according to the difficulty level values. The edge connection construction adopts a three-stage weighting mechanism: the weight of the strong connection edge is set to 1.0, the weight of the weak connection edge is set to 0.5, and the weight of the hierarchical connection edge is set to 0.8. In the relationship modeling stage, the system uses a graph embedding algorithm to process nodes and edges: the Node2Vec model is used for random walk sampling, the walk length is set to 10, and the walk number is set to 100; the Skip-gram model is used to learn node embedding representation, and a 128-dimensional node embedding vector is generated; the TransE model is used to model the edge relationship, and the edge type is mapped to a relationship vector. The graph embedding process produces dual output: the node embedding matrix stores the vector representation of all tasks, and the edge relationship tensor stores the connection type and weight. The initial cognitive graph is stored in a graph data structure, including a node set (task ID + embedding vector), an edge set (connection type + weight), and global attributes (graph version identifier). The initial cognitive graph serves as an input carrier for the S410 module, and its node embedding vector is directly used for message passing in the graph neural network of S420.

[0101] Step S300 includes at least steps S310-S330:

[0102] S310, obtain standardized behavior data, and calculate the error rate change gradient and switching delay increment during task concurrency.

[0103] The system receives the standardized behavior data from S130 and processes the multi-dimensional feature vector through a thread capacity calculation engine. Specifically, the standardized behavior data contains seven dimensions of features: switching delay mean, switching delay variance, maximum switching delay, switching delay change gradient, concurrent error density, cross-task error correlation, and error propagation intensity. For error rate change gradient calculation, the system adopts a time window segmentation mechanism: taking the starting point of task concurrency as the benchmark, the concurrency process is divided into 5 equal length time periods; in each time period, the concurrent error density feature value is extracted, and the local change rate is calculated by the difference value of error density between adjacent time periods; finally, a weighted average algorithm is used to integrate the local change rates, and the weight is allocated according to the length proportion of the time period, to generate the overall error rate change gradient value. For switching delay increment calculation, the system performs a double comparison operation: first, compare the difference between the switching delay mean values in multi-task and single-task states to obtain the absolute increment; second, analyze the variance change of switching delay at adjacent switching points in the task switching sequence to calculate the variance growth rate. In the calculation process, the system introduces a time decay factor, so that the recent behavior data has a higher weight, enhancing the model's response sensitivity to the current cognitive state. The thread capacity calculation engine outputs structured calculation results: including the scalar value of the error rate change gradient, the three-dimensional vector of the switching delay increment (absolute increment value, variance growth value, peak offset), forming the primary parameter set of thread capacity calculation.

[0104] S320, fitting an individual cognitive resource decay curve according to the error rate change gradient and the switching delay increment.

[0105] The system receives S310 the generated primary parameter set and performs curve fitting through a cognitive attenuation modeler. Specifically, a two-channel collaborative modeling architecture is adopted: the first channel processes the error rate change gradient, which is mapped to the cognitive resource consumption rate indicator; the second channel processes the switching delay increment three-dimensional vector, which is converted into the cognitive resource allocation efficiency indicator. The cognitive attenuation modeler adopts a piecewise function fitting strategy: linear fitting is used in the initial stage (0-3 seconds) of task concurrency to establish a rapid resource consumption model; logarithmic fitting is used in the stable stage (3-8 seconds) to simulate a sustained resource attenuation pattern; exponential fitting is applied in the critical stage (>8 seconds) to predict the resource exhaustion inflection point. For the error rate channel, the system establishes a gradient-attenuation mapping table: when the error rate change gradient is less than 0.1, it is marked as slow attenuation, 0.1-0.3 as moderate attenuation, and greater than 0.3 as rapid attenuation. For the switching delay channel, the system performs vector synthesis operation: the absolute increment value, variance growth value and peak offset value are fused through a weighted fusion formula to generate a comprehensive delay coefficient, and the coefficient size is positively correlated with the cognitive resource competition intensity. The curve fitting process introduces a personalized calibration mechanism: based on the best performance record in the user's historical test data, an individual baseline attenuation model is established, and the deviation parameter is generated by comparing the current fitting curve with the baseline model. The cognitive resource attenuation curve completed by fitting is stored in the form of a parameterized equation, including three core features: slope parameter, inflection point coordinates and asymptote value.

[0106] S330, based on the cognitive resource attenuation curve, determine the maximum number of threads that can be maintained, and perform personalized resource allocation modeling to obtain the dynamic thread capacity parameter.

[0107] The system receives the parameterized attenuation curve equation output by S320, and calculates the thread capacity threshold through a resource allocation optimizer. Specifically, a critical point detection algorithm is used: scanning the critical position on the attenuation curve where the rate of curvature change exceeds the preset threshold, the time point corresponding to the position is the maximum sustainable time; according to the time-thread conversion formula of thread cognition theory, the sustainable time is converted into the equivalent number of threads. The resource allocation optimizer performs three-stage optimization: the first stage performs capacity upper limit constraint, and sets the initial maximum number of threads to 5; the second stage performs attenuation compensation calculation, and when the curve slope is greater than 0.2, the compensation mechanism is started, and for every increase of 0.1 slope value, 0.5 equivalent threads are reduced; the third stage applies individual difference correction, and refers to the concurrent error density characteristic value in S130, and for every increase of 0.1 unit of error density, the thread capacity is reduced by 0.2. In the modeling process, the system constructs a multi-dimensional resource allocation matrix: the cognitive resources are divided into three types of attention resource slot, working memory slot and executive control slot, and according to the resource demand characteristics extracted in S210, the weights of each slot are allocated. The personalized resource allocation modeling outputs a dynamic thread capacity parameter, which includes a three-dimensional vector: total thread capacity value, resource slot capacity distribution vector, and capacity confidence coefficient. The dynamic thread capacity parameter is packaged in JSON format and real-time pushed to the S410 module for accurate injection into the global node of the cognitive graph.

[0108] Step S400 at least includes steps S410-S430:

[0109] S410, inject the dynamic thread capacity parameter into the global attribute node of the initial cognitive graph.

[0110] The system receives the dynamic thread capacity parameters from S330, and fuses them with the initial cognitive graph through a graph injection engine. Specifically, the dynamic thread capacity parameters include a three-dimensional vector: total thread capacity value, resource slot capacity distribution vector, and capacity confidence coefficient. The initial cognitive graph is obtained from the S230 module, and its data structure includes a node set (task ID and 128-dimensional embedding vector), an edge set (connection type and weight value), and global attributes (graph version identifier). The graph injection engine performs a three-stage injection operation: the first stage parses the capacity parameter vector and maps the total thread capacity value to a global cognitive resource total scalar; the second stage decomposes the resource slot distribution vector and converts the capacity values of the attention resource slot, working memory slot, and execution control slot into normalized coefficients in the 0-1 interval; the third stage establishes the association rules between the capacity parameters and the graph nodes, and according to the resource demand features extracted in S210, the weight distribution of the corresponding resource slots is matched. During the injection process, the system creates a new global attribute node that stores four-dimensional attributes: total capacity scalar, attention coefficient, memory coefficient, and control coefficient. The global attribute node establishes a virtual edge with all task nodes through a bidirectional connection mechanism, and the virtual edge weight is dynamically calculated according to the resource demand features encoded in S220. The cognitive graph with the injected capacity features adds a global capacity feature layer, and the graph version identifier is updated synchronously, marking the capacity parameter injection timestamp and parameter fingerprint.

[0111] S420, using a graph neural network to perform multiple rounds of message passing on the injected cognitive graph to predict the cognitive resource competition intensity of the task combination.

[0112] The system receives S410 the post-injection cognitive map output, and performs multi-round message passing through a graph neural network analyzer. Specifically, the graph neural network adopts a three-layer graph convolution architecture: the first layer processes node features, concatenates 128-dimensional node embedding vectors and global capacity parameters into 132-dimensional input features; the second layer processes edge features, and according to the strong connection (weight 1.0), weak connection (weight 0.5) and hierarchical connection (weight 0.8) three types of edge defined by the edge set, respectively constructs the adjacency matrix; the third layer integrates virtual edge features, and takes the virtual edge of the global attribute node and the task node as a special connection channel. The message passing mechanism includes three core operations: in the message generation stage, each task node generates attention resource request signals, working memory occupation signals and execution control application signals according to the resource demand vector; in the message aggregation stage, the signals sent by the neighbor nodes are integrated by using the weighted summation algorithm, and the weight is determined by the edge type (the strong connection takes a 1.0 coefficient, the weak connection takes a 0.5 coefficient, and the virtual edge takes a 0.3 coefficient); in the node update stage, the historical state and the aggregated message are fused through the gated recurrent unit to generate a new node state vector. The multi-round message passing performs fixed 5 rounds of iteration: the first two rounds focus on the direct resource competition between task nodes, and the last three rounds introduce global capacity constraints for resource reallocation simulation. In the final round, the system outputs the task combination competition intensity matrix: for each possible multi-task combination (containing 2-4 tasks), the difference between the total resource demand of the nodes in the combination in the attention slot, the memory slot and the control slot and the global capacity coefficient is calculated, and the Euclidean distance of the three differences is taken as the original competition intensity value.

[0113] S430, outputting the conflict intensity index according to the cognitive resource competition intensity, and generating the conflict intensity index.

[0114] The system receives S420 the output task combination competition intensity matrix, and generates a standardized index through a conflict quantifier. Specifically, the conflict quantifier performs a four-step processing procedure: the first step performs intensity normalization, linearly converts the original competition intensity value to the 0-1 interval, and the conversion formula is (actual value-minimum intensity value) / (maximum intensity value-minimum intensity value); the second step introduces capacity confidence compensation, adjusts the index value according to the capacity confidence coefficient in S330, and the conflict intensity increases by 0.05 for every 0.1 decrease in confidence; the third step performs multi-task type calibration, applies a 1.2 times pressure coefficient to the multi-task combination, applies a 1.0 times coefficient to the task switching combination, and applies a 0.8 times coefficient to the task interruption combination; the fourth step performs timing conflict superposition, and for combinations containing task switching or interruption, the competition intensity increment value of the adjacent task switching point is increased. The conflict intensity index is a floating-point scalar, stored in the task combination conflict library, and each entry contains four attributes: combination ID (containing task ID sequence), conflict intensity value, resource competition type label, and update timestamp. The index generation process establishes a version association mechanism, binds the conflict intensity value with the graph version identifier of S410, and ensures traceability. The generated conflict intensity index is pushed to the S510 module through the message queue as the core input parameter of the safe task combination screening.

[0115] In another embodiment, S410: Improved Hamilton-Chebyshev graph injection model.

[0116] The system receives dynamic thread capacity parameters from S330 , wherein represents the total thread capacity scalar value, represents the attention / memory / executive control three-resource slot capacity distribution vector, represents the capacity confidence coefficient. Initial cognitive graph obtained from the S230 module, wherein is a set of task nodes of the cognitive graph, containing task nodes, each node having a 128-dimensional embedding vector ( ), is an edge set of the cognitive graph.

[0117] Construct a global attribute node injection function:

[0118]

[0119] wherein:

[0120] : global attribute node vector;

[0121] total capacity normalization function;

[0122] resource slot distribution normalization function

[0123] capacity confidence coefficient

[0124] further, the virtual edge weight generation formula

[0125]

[0126] wherein

[0127] virtual edge weight

[0128] resource requirement vector of task node i

[0129] resource requirement vector of task node k

[0130] : second component (resource slot coefficient) of

[0131] total number of task nodes in the graph

[0132] Technical implementation: the system performs three-stage operations through the graph injection engine. First, the parameters are parsed and formula 1 is applied to generate four-dimensional global attributes . Then, virtual edges are created to connect all task nodes and global nodes, and formula 2 is applied to calculate the weight of each virtual edge . Finally, the enhanced graph is output, where represents the newly added virtual edge set.

[0133] The system receives the dynamic thread capacity parameters generated by the S330 module, which include the total thread capacity value, the capacity distribution vector of three types of resource slots, and the capacity confidence coefficient. Through the three-stage processing flow of the graph injection engine: first, the total capacity value is normalized to adapt to the numerical range of the cognitive graph; second, the resource slot capacity distribution vector is converted into a proportion coefficient, maintaining the relative relationship of each resource type; finally, the processed parameters are fused with the initial cognitive graph. In the fusion process, the system creates a global attribute node to store the capacity parameters and establishes a dynamic association between the node and all task nodes through the virtual edge connection mechanism. The weight value of the virtual edge is generated by calculating the matching degree of the task node resource requirement and the global resource slot coefficient, and finally the enhanced cognitive graph structure is output.

[0134] S420: improved riemannian manifold graph convolution network​

[0135] Define the initial state of the node:

[0136]

[0137] in, : node initial state vector;

[0138] is the 128-dimensional node embedding vector of S230;

[0139] Represents a vector concatenation operation.

[0140] Furthermore, the Riemannian manifold message passing function is constructed:

[0141]

[0142] in:

[0143] : No. The message vector of the layer;

[0144] : Sigmoid activation function;

[0145] : The neighbor set of node i;

[0146] : 2D rotation matrix;

[0147] : resource demand vector angle (radians);

[0148] : The connectivity of node i (number of adjacent nodes);

[0149] Furthermore, the node state update equation is:

[0150]

[0151] in, is the state vector of node i in layer l; is the historical state vector of node i in the l−1th layer; For the The message vector of the layer; is the global attribute node vector; represents Hadamard product (element-wise multiplication), and GRU is gated recurrent unit.

[0152] Technical implementation: system loading After that, five rounds of iterative calculations are performed ( To In each iteration: 1) aggregate neighbor messages according to Formula 4, where Edge weights taken from S230; 2) update node states according to Formula 5. The final output is the stable state of all nodes .

[0153] Based on the enhanced graph output from S410, the system initializes the node state vectors of the graph neural network, which are concatenated from the original node embedding features and global attribute node parameters. In the message passing phase, an improved neighbor information aggregation strategy is adopted: the resource demand direction difference between different task nodes is processed through a rotation matrix, the network topology bias is eliminated by degree normalization, and a gating mechanism is introduced to dynamically integrate historical states and global constraints. After five rounds of iteration calculations, each task node generates a state vector containing the latest resource competition information. The key innovation of this module lies in modeling the spatial distribution characteristics of cognitive resources as geometric transformations on Riemannian manifolds, thereby more accurately simulating the resource competition dynamics in a multi-task environment.

[0154] S430: Improved Shannon Entropy-Monte Carlo Conflict Quantification

[0155] For task combination ( ), calculate the resource competition tensor:

[0156]

[0157] where,

[0158] : Resource competition tensor;

[0159] : Attention resource requirement of task k;

[0160] : Global attention capacity;

[0161] : Working memory requirement of task k;

[0162] : Global working memory capacity;

[0163] : Executive control requirement of task k;

[0164] : Global executive control capacity;

[0165] Further, construct the Shannon entropy conflict measure:

[0166]

[0167] wherein, : Shannon entropy conflict metric;

[0168] : Resource slot type index, A=attention, M=working memory, E=executive control;

[0169] Normalized competition intensity ratio of task combination K on resource slot s;

[0170] Final conflict intensity generation:

[0171]

[0172] wherein,

[0173] : Final conflict intensity indicator;

[0174] : Task switch time variance;

[0175] : Task type coefficient (multiple task 1.2, switch 1.0, interruption 0.8);

[0176] : Timing conflict weight coefficient;

[0177] Technical implementation: the system traverses all possible task combinations (about , for each combination: 1) calculate resource competition according to formula 6; 2) calculate entropy value according to formula 7; 3) generate conflict intensity according to formula 8. The results are stored in the conflict library, including four tuples .

[0178] The system traverses all possible task combinations, and performs three-level quantitative analysis for each combination: first, calculate the difference between the cumulative demand of each task in the combination for the three types of resource slots and the global capacity, and generate a resource competition tensor; second, convert the tensor value into a probability distribution and calculate the Shannon entropy, which quantifies the uncertainty degree of resource competition; finally, fuse the entropy value, capacity confidence, task switch time characteristics and task type coefficient to generate a standardized conflict intensity indicator. In this process, the node state output by S420 provides real-time resource demand data, the time series characteristics recorded by S120 strengthen the timing conflict assessment, and the capacity confidence parameter of S330 ensures the reliability of the indicator. All calculation results are stored in the conflict knowledge base, providing decision basis for downstream modules.

[0179] Step 500 at least contains steps S510-S530:

[0180] S510, obtaining the conflict intensity index, filtering the task combination whose conflict intensity exceeds the preset threshold, and obtaining the safe task combination set.

[0181] The system receives the conflict intensity index dataset from S430, and performs safe combination screening through the conflict filter. Specifically, the conflict intensity index dataset is stored in the task combination conflict library, and each entry contains four types of attributes: combination ID, conflict intensity value, resource competition type label, and update timestamp. The conflict filter first loads the preset conflict threshold, which is adaptively set according to the dynamic thread capacity parameter in S330: when the total thread capacity value is greater than 4.0, the threshold is set to 0.3, when the capacity value is 3.0-4.0, the threshold is set to 0.25, and when the capacity value is less than 3.0, the threshold is set to 0.2. The filtering operation is performed in three steps: the first step is to traverse all entries in the conflict library and mark the combinations whose conflict intensity values exceed the threshold; the second step is to perform resource competition type verification, and additionally increase the threshold tolerance of 0.05 for the combinations marked as "attention dominant competition"; the third step is to perform timeliness verification and remove the combinations whose update timestamps are earlier than the last S410 graph injection time. During the filtering process, the system establishes a dynamic exclusion mechanism: when a task ID is marked as high conflict in more than 50% of the combinations, the task is added to the temporary disable list. The filtering operation generates a safe task combination set, which contains three metadata: combination ID sequence, maximum conflict intensity value, and available resource slot distribution. The safe task combination set is stored in the temporary working area of the graph database, and its data structure maintains the node ID mapping relationship with the initial cognitive graph in S230.

[0182] S520, selecting multiple task combinations, task switching combinations and task interruption combinations from the safe task combination set.

[0183] The system receives S510 the generated set of safe task combinations, and performs classification extraction through a task selector. Specifically, a graph structure-based traversal algorithm is adopted: first, multiple task combinations are identified, and combinations containing at least two concurrent task nodes are screened in the safe set, where the nodes must satisfy the complementary resource requirement characteristics defined in S220 (such as the pairing of high attention requirement and low working memory requirement); second, task switching combinations are retrieved, and combinations containing three or more nodes and having S230 hierarchical connection edge identifiers are selected; finally, task interruption combinations are located, and node combinations with "interruption recovery markers" are searched, which are derived from the concurrent error characteristic analysis results in S130. The selector performs priority sorting: multiple task combinations are arranged in descending order according to the number of concurrent tasks; task switching combinations are arranged in ascending order according to the switching path length (the time sequence span defined in S120); task interruption combinations are arranged in descending order according to the interruption recovery efficiency value (calculated according to the error propagation strength in S130). In the selection process, the system implements load balancing control: multiple task combinations do not exceed 40% of the total selection amount, task switching combinations account for 40%, and task interruption combinations account for 20%. The final output of the three types of combination set contains complete graph information: each combination carries node embedding vectors (from S230), edge connection weights (from S420 message passing results), and conflict intensity history records (from S430).

[0184] S530, time axis arrangement and difficulty balance are performed on the selected three types of task combinations, multi-task sequence optimization is performed, and a multi-task test instruction set is generated.

[0185] The system receives S520 the output of the classification combination set, and generates test instructions through a sequence optimization engine. Specifically, the arrangement process has two dimensions: in the time axis dimension, the statistical law of the time-synchronized behavior sequence is used to set the interval parameter according to S120, that is, the starting time deviation of each task in the multiple task combination does not exceed 200 milliseconds; the switching interval of the task switching combination is set to 1.2 times the duration of the previous task; the interruption trigger point of the task interruption combination is set in the middle ±10% interval of the task duration. In the difficulty balance dimension, the difficulty level feature of S210 is called to perform three-level adjustment: first, the overall difficulty mean of the combination is calculated, which is constrained within the ability interval reflected by the user S130 standardized behavior data; second, difficulty fluctuation control is implemented, and the difficulty difference between adjacent tasks does not exceed 0.3 units; finally, dynamic difficulty injection is added, and when it is detected that the switching delay increment of S310 is lower than the historical mean, the difficulty of the subsequent task is increased by 0.1 level. The sequence optimization uses a genetic algorithm iteration: the initial population size is 200 sequences, the fitness function integrates the conflict intensity (weight 0.6), the difficulty gradient (weight 0.3), and the time efficiency (weight 0.1), and the optimal solution is selected after 50 generations of evolution. The generated multi-task test instruction set uses a hierarchical JSON format: the top layer defines the sequence type (concurrent / switching / interruption), the middle layer describes the task ID sequence and time parameters, and the bottom layer embeds the S220 node attribute data. The instruction set is transmitted to the S610 test engine through an encrypted channel, and its data structure includes the interface specification of the S620 feedback link.

[0186] Step S600 at least includes steps S610-S630:

[0187] S610, load the multi-task test instruction set, and execute the sequence of concurrent tasks, switching tasks, and interruption tasks in the test engine.

[0188] The system receives the multi-task test instruction set from S530, and parses the instruction structure through the test loader. Specifically, the multi-task test instruction set is stored in a hierarchical JSON format: the top layer contains a sequence type identifier (concurrent sequence / switching sequence / interruption sequence), a total duration threshold, and a resource occupation warning value; the middle layer defines a task ID sequence and time control parameters, including a concurrent task start time deviation threshold (≤200 milliseconds), a task switching interval coefficient (1.2 times the duration of the previous task), and an interruption trigger time window (±10% interval during task duration); the bottom layer embeds S220 node attribute data, including operation type code, resource requirement vector, and difficulty level value. The test loader activates the corresponding execution mode according to the sequence type: for concurrent sequences, all task instances in the instruction set are started synchronously, and the thread allocator ensures that each task runs in an independent thread; for switching sequences, a task queue stack is constructed, and task rotation is automatically triggered based on the preset switching interval coefficient; for interruption sequences, an interruption monitor is deployed while the main task thread runs in the background, and an interruption event is injected when the system time enters the preset interruption time window. The event scheduling layer of the test engine uses a priority queue mechanism: interruption tasks have the highest priority, switching tasks have the second highest priority, and concurrent tasks have the basic priority. All task instances call the operation type processing logic defined by S210 when executing, and are constrained by the dynamic thread capacity parameter of S330.

[0189] S620, record the real-time operation behavior of the user during execution, and establish a real-time feedback link.

[0190] The system collects real-time operation behavior data through distributed probes during the test engine execution process. Specifically, the distributed probes are deployed at three key collection points: the task presentation module records the task start timestamp, the response capture module records the user operation submission time and content, and the interruption processing module marks the interruption occurrence and recovery time points. The collected data includes four types of core information: response delay data (the time difference between task presentation and operation submission), operation result data (the matching status of user input and standard answer), task state transition data (start / switch / interrupt / terminate events), and resource occupation data (memory and CPU usage). The feedback link establishment adopts a dual-channel architecture: the main channel transmits behavior data in real time through WebSocket, and every 200 milliseconds, a data packet containing five tuples of task ID, operation type, timestamp, response value, and result status is transmitted; the auxiliary channel stores detailed operation traces through a log buffer queue, and adds millisecond-level timestamps according to the time synchronization specification defined in S120. The real-time operation behavior data set is stored in the same JSON structure as S110, with a new resource occupation field added for subsequent thread capacity analysis. The data collection process implements integrity verification: after completing a task sequence (concurrent / switch / interrupt), the system automatically compares the number of collected data points with the expected number of operation steps, and triggers the data retransmission mechanism when the missing rate exceeds 5%.

[0191] S630, input the real-time operation behavior into the standardized behavior data collection process for dynamic data collection and model updating.

[0192] The system injects the real-time operation behavior data set collected in S620 into the standardized processing pipeline. Specifically, the standardized processing pipeline includes three levels of linkage: the first level performs data format conversion, mapping the original behavior data in JSON format to the five attribute structure defined in S120 (standardized timestamp, task type code, response delay value, error rate value, and task state flag); the second level calls the data cleaning process of S130, using the same three-stage outlier processing mechanism: initial screening based on quartile range method, task type baseline filtering, and dynamic threshold removal; the third level performs feature regeneration, extracting task switch delay features and concurrent error features according to the sliding window statistics method of S130, generating new standardized behavior data. The model updating adopts an incremental learning mechanism: the newly generated standardized behavior data is appended to the feature repository of S130, triggering three types of model updating: S300 thread capacity model incremental training, updating the cognitive resource decay curve parameters with new data; S420 graph neural network model fine-tuning, optimizing the message passing weights through new conflict samples; S510 security combination screening model calibration, dynamically adjusting the conflict threshold according to the latest behavior data. When the dynamic data collection is completed, a version update identifier is generated, which is synchronized to the S410 global attribute node, ensuring the consistency of the global cognitive graph version across the system.

[0193] Embodiment Two: Figure 2 A structural block diagram of a multi-task automatic question setting system according to an embodiment of the present application is shown. As shown, the structure can include: Figure 2

[0194] A real-time behavior collection module 10 performs collection of real-time behavior data in a multi-task test, data cleaning and feature extraction, and obtains standardized behavior data.

[0195] Embedded data capture: integrated in the event scheduling layer of the test engine, real-time monitoring of user interaction events through event-driven architecture, collection of multi-task start time stamps, task switching interval time, interruption event markers and recovery time.

[0196] Core data collection: acquisition of response delay data (time difference between task presentation and effective response) and error rate data (deviation rate of operation result and standard answer), storage as JSON format logs according to task type classification, containing five tuples of task ID, type, timestamp, response value and result status.

[0197] Data preprocessing: real-time transmission of raw data to the central processing node through the WebSocket protocol to provide input source for time series alignment.

[0198] Cognitive map construction module 20 performs construction of cognitive task feature map, node embedding and relationship modeling, and obtains an initial cognitive map.

[0199] Feature extraction engine: parsing of operation type features (navigation / communication / troubleshooting classification coding), resource demand features (five-level quantization vector of attention / work memory / executive control), and difficulty level features (0.1 precision continuous value based on historical completion rate) from the preset cognitive task library.

[0200] Node attribute coding: using hierarchical coding technology to convert features into graph node attribute vectors (8-dimensional operation type one-hot coding + 3-dimensional resource demand normalization + 1-dimensional difficulty segmentation coding), and reducing dimension to 5 dimensions through principal component analysis.

[0201] Relationship modeling: based on cognitive ability overlap to build three types of edge connections (strong connection with resource similarity>0.7, weak connection with operation type complementarity, hierarchical connection with difficulty progression), and generate 128-dimensional node embedding vectors and relationship tensors through Node2Vec and TransE models.

[0202] Thread capacity modeling module 30 performs dynamic calculation of thread capacity threshold based on standardized behavior data, personalized resource allocation modeling, and obtains dynamic thread capacity parameters.

[0203] ​Behavioral feature analysis: Calculate the error rate change gradient of concurrent tasks (weighted average of local change rates by time period) and the switching delay increment (multiple / single task mean difference and variance growth ratio).

[0204] Decay curve fitting: A piecewise function strategy was used to fit the individual cognitive resource decay curve (0-3 seconds linear decay, 3-8 seconds logarithmic decay, >8 seconds exponential decay).

[0205] Capacity parameter generation: The maximum sustainable number of threads is determined through critical point detection. Combined with the resource allocation matrix (weighted allocation of attention, memory, and control slots), dynamic thread capacity parameters (total capacity value, slot distribution vector, and confidence coefficient) are output.

[0206] The conflict prediction module 40 performs cognitive conflict prediction by fusing the dynamic thread capacity parameter with the initial cognitive map to generate a conflict intensity index.

[0207] Graph fusion: Inject capacity parameters into global attribute nodes to generate a four-dimensional vector (total capacity scalar, three resource slot coefficients), and connect all task nodes through the virtual edge weight formula.

[0208] Competition intensity prediction: Based on the Riemannian manifold graph convolutional network, five rounds of message passing are performed (including rotation matrix processing resource direction differences and degree normalization to eliminate topological deviations), and the node state vector is output.

[0209] Conflict quantification: Calculate the resource contention tensor of the task combination (the difference between the demand and capacity of the three resource slots), quantify the uncertainty using Shannon entropy, and integrate the timing characteristics (S120 switching time variance) to generate a conflict intensity index.

[0210] The task optimization module 50 is used to screen the safety task combination according to the conflict intensity index, optimize the multi-task sequence, and generate a multi-task test instruction set.

[0211] Safe combination screening: Filter high-conflict combinations based on dynamic thresholds (adaptively adjusted with capacity parameters), combined with resource contention type verification (for example, adding a 0.05 tolerance for "attention-dominant").

[0212] Classification combination selection: Select multi-task combination (40%), task switching combination (40%), and interrupt task combination (20%) according to load balancing rules, and sort them according to the number of concurrent tasks, switching path length, and interruption recovery efficiency.

[0213] Sequence optimization: Genetic algorithms are used for timeline arrangement (concurrent task start deviation ≤ 200ms, switching interval = previous task duration × 1.2) and difficulty balance (difficulty difference between adjacent tasks ≤ 0.3) to generate a hierarchical JSON instruction set.

[0214] Test execution and feedback module 60 executes multi-task test instruction set and establishes real-time feedback link, conducts dynamic data collection and model updating.

[0215] Instruction set loading: parse instruction set structure, activate concurrent / switch / interrupt execution mode according to sequence type, schedule tasks through priority queue (interrupt task> switch task> concurrent task).

[0216] Real-time behavior recording: distributed probe collects four types of data (response delay, operation result, state transition, resource occupation), double-channel transmission ensures integrity (WebSocket real-time package + log buffer queue).

[0217] Closed-loop updating: inject new behavior data into standardized pipeline, trigger three types of incremental updating (thread capacity model re-fitting, graph neural network fine-tuning, conflict threshold dynamic calibration), synchronize graph version identification updating.

[0218] Obviously, the above-described embodiments are only a part of the embodiments of the present application, and are not all the embodiments. The preferred embodiments of the present application are shown in the drawings, but do not limit the patent scope of the present application. The present application can be implemented in many different forms, and conversely, the purpose of providing these embodiments is to make the disclosure of the present application more thorough and comprehensive. Although the present application has been described in detail with reference to the foregoing embodiments, those skilled in the art can still modify the technical solutions recorded in the foregoing specific embodiments, or make equivalent replacements to some technical features. Any equivalent structure made by using the content of the specification and drawings, directly or indirectly applied to other related technical fields, is also within the scope of the patent protection of the present application.

Claims

1. A multi-task automated question matching method, characterized in that: include: Collect real-time behavioral data from multi-task tests, perform data cleaning and feature extraction, and obtain standardized behavioral data; Construct a cognitive task feature map, perform node embedding and relationship modeling, and obtain an initial cognitive map; Dynamically calculate thread capacity thresholds based on standardized behavior data, perform personalized resource allocation modeling, and obtain dynamic thread capacity parameters; The process of obtaining the dynamic thread capacity parameter includes: Obtain standardized behavioral data and calculate the error rate change gradient and switching delay increment during task concurrency; The individual cognitive resource decay curve is fitted based on the error rate change gradient and the switching delay increment; Determine the maximum number of sustainable threads based on the cognitive resource decay curve, perform personalized resource allocation modeling, and obtain dynamic thread capacity parameters; The dynamic thread capacity parameter and the initial cognitive map are integrated to predict cognitive conflict and generate a conflict intensity index. The expression for cognitive conflict prediction is: in, For the The message vector of the layer; is the activation function; is the neighbor set of node i; is a two-dimensional rotation matrix; is the angle between resource demand vectors; is the connectivity of node i; Furthermore, the node state update equation is: in, is the state vector of node i in layer l; is the historical state vector of node i in the l−1th layer; For the The message vector of the layer; is the global attribute node vector; represents Hadamard product (element-wise multiplication), GRU is gated recurrent unit; The expression for generating the conflict intensity index is: in, is the final conflict intensity indicator; is the Shannon entropy conflict measure; is the capacity confidence coefficient; is the timing conflict weight coefficient; is the task switching time variance; is the task type coefficient; Screen the security task combination according to the conflict intensity index, optimize the multi-task sequence, and generate a multi-task test instruction set; Execute multi-task test instruction sets and establish real-time feedback links to conduct dynamic data collection and model updates.

2. The multi-task automated question-matching method according to claim 1, characterized in that: Collecting real-time behavioral data during multi-task testing includes: During the test execution, the user's multi-task operation logs are collected to obtain response delay data and error rate data; Perform time series alignment on response delay data and error rate data to generate behavior sequences with synchronized timestamps. Task switching delay features and concurrency error features are extracted from the behavior sequence, and data cleaning and feature extraction are performed to obtain standardized behavior data.

3. The multi-task automated question-matching method according to claim 1, characterized in that: Constructing a cognitive task feature map includes: Extract the task's operation type characteristics, resource requirement characteristics, and difficulty level characteristics from the preset cognitive task library; Encode operation type features, resource requirement features, and difficulty level features as graph node attributes; Based on the overlapping relationship of cognitive abilities between tasks, edge connections are constructed, node embedding and relationship modeling are performed to obtain the initial cognitive map.

4. The multi-task automated question-matching method according to claim 1, characterized in that: Cognitive conflict predictions include: Inject dynamic thread capacity parameters into the global attribute nodes of the initial cognitive graph; Utilize graph neural networks to perform multiple rounds of message passing on the injected cognitive graph to predict the intensity of cognitive resource competition for task combinations. The conflict intensity index is output according to the intensity of cognitive resource competition to generate a conflict intensity index.

5. The multi-task automated question-matching method according to claim 1, characterized in that: The screening security task portfolio includes: Obtain a conflict intensity index, filter task combinations whose conflict intensity exceeds a preset threshold, and obtain a safe task combination set; Select a multi-task combination, a task switching combination, and a task interrupt combination from the safety task combination set.

6. The multi-task automated question-matching method according to claim 1, characterized in that: Generating a multi-task test instruction set includes: The timeline of multiple task combinations, task switching combinations and task interruption combinations are arranged and the difficulty is balanced to generate a multi-task test instruction set.

7. The multi-task automated question-matching method according to claim 1, characterized in that: The multi-tasking test instruction set includes: Loading the multi-task test instruction set, executing a sequence of concurrent tasks, switching tasks, and interrupt tasks in the test engine; Record the user's real-time operation behavior during the execution process and establish a real-time feedback link.

8. The multi-task automated question-matching method according to claim 1, characterized in that: Dynamic data collection and model updating include: Input real-time operational behaviors into the standardized behavioral data collection process for dynamic data collection and model updates.

9. A multi-task automated question matching system, used to implement the method according to any one of claims 1 to 8, characterized in that: include: The real-time behavior collection module collects real-time behavior data from multi-task tests, performs data cleaning and feature extraction, and obtains standardized behavior data. The cognitive map construction module builds the cognitive task feature map, performs node embedding and relationship modeling, and obtains the initial cognitive map; The thread capacity modeling module dynamically calculates thread capacity thresholds based on standardized behavior data, performs personalized resource allocation modeling, and obtains dynamic thread capacity parameters; The conflict prediction module performs cognitive conflict prediction by fusing dynamic thread capacity parameters with the initial cognitive map and generates a conflict intensity index. The task optimization module screens the combination of safety tasks according to the conflict intensity index, optimizes the multi-task sequence, and generates a multi-task test instruction set; The test execution and feedback module executes the multi-task test instruction set and establishes a real-time feedback link to perform dynamic data collection and model update.

Images