Multi-task automatic question matching method and system

Abstract

The invention belongs to the cross technical field of artificial intelligence and cognitive evaluation, and discloses a multi-task automatic question matching method and system. The core method comprises the steps of collecting real-time behavior data of multi-task operation of a user, and extracting standardized features through cleaning; constructing a cognitive task feature map and establishing a task relation model through node embedding; an individual thread capacity threshold value is dynamically calculated based on the behavior data, and personalized resource allocation parameters are generated; injecting the capacity parameters into the map to predict cognitive conflict intensity indexes; screening security task combinations according to conflict intensity, and performing time axis arrangement and difficulty balance to generate a test instruction set; and executing the instruction set and establishing a feedback link to realize data closed-loop updating. The cognitive resource adaptation limitation of traditional static matching is broken through, through the dynamic capacity modeling and conflict prediction technology, accurate generation of a multi-task combination in a high-risk occupational complex scene is achieved, and the work performance prediction validity and the system self-adaptive capacity are greatly improved.

Description

Technical Field

[0001] The present invention belongs to the interdisciplinary technical field of artificial intelligence and cognitive psychology, and in particular relates to a multi-task automated question matching method and system. Background Art

[0002] Predicting job performance for special occupations such as pilots has always been a very important issue. Due to the high risk and complexity of their actual work, people attempt to select suitable personnel to perform tasks through cognitive ability tests. In the field of psychology, there are already many classic paradigms for tests of cognitive abilities such as attention and working memory. However, since real work requires facing complex multi-tasking scenarios, these classic tests have low predictive ability for job performance. On this basis, a general solution is to conduct a comprehensive measurement of a single individual, that is, it is necessary to complete various types of cognitive tests continuously, which usually relies on a static task allocation method, that is, experts conduct tests after selecting questions based on experience, and fail to fully consider individual differences in the performance of multiple tasks. At the same time, the scientific community lacks a scientific framework to guide how to transform theoretical multi-tasking capabilities into task design in practical applications. Analysis of defects in existing technologies: (1) Static item assignment limitations. Traditional cognitive ability tests (such as the N-back working memory test and the Stroop attention test) rely on expert experience to statically combine tasks and are unable to dynamically adapt to individual cognitive resource fluctuations. For example, in pilot selection, static combination tests generally have low predictive validity for actual flight performance.

[0003] (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: Ignore directional competition for attention, working memory, and executive control resources; Unable to simulate timing resource preemption caused by task interruption / switching; This results in a high deviation between the generated task combination and the actual operation scenario.

[0004] (3) Insufficient adaptability to individual differences. Mainstream adaptive tests (such as CAT systems) only adjust the difficulty of a single task and fail to address the personalized issues in multi-task concurrent scenarios: The thread capacity threshold is fixed and not dynamically calibrated based on real-time behavioral data (response latency / error rate); Lack of individualized modeling tools such as the "cognitive resource decay curve"; This results in a higher mismatch rate for high cognitive load task combinations. Summary of the Invention

[0005] 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.

[0006] In order to solve the above technical problems, the present invention provides a multi-task automated question matching method, comprising: 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 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: 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.

[0007] Furthermore, collecting real-time behavioral data in a multi-task test 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 a behavior sequence 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.

[0008] Furthermore, 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.

[0009] Furthermore, dynamically calculating the thread capacity threshold 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; The maximum number of sustainable threads is determined based on the cognitive resource decay curve, and personalized resource allocation modeling is performed to obtain dynamic thread capacity parameters.

[0010] Furthermore, 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.

[0011] Furthermore, the screening security task combination 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.

[0012] Furthermore, 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.

[0013] Furthermore, executing the multi-task 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.

[0014] Furthermore, 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.

[0015] A multi-task automated question-matching system, used to implement any of the above methods, comprising: 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.

[0016] The key innovations of the present invention include: (1) Transform cognitive thread theory into calculable capacity parameters, and achieve real-time quantification of individual cognitive abilities through resource decay curve modeling, providing a scientific basis for personalized question matching.

[0017] (2) Develop a global attribute node and virtual edge connection mechanism to embed dynamic capacity parameters into the task relationship graph in a breakthrough way, solving the problem of structural integration of cognitive resource constraints and task characteristics.

[0018] (3) We propose a graph convolution model based on Riemannian manifolds, analyze the directional competition characteristics of cognitive resources through rotation matrices, and overcome the quantitative prediction bottleneck of resource preemption in a multi-task environment.

[0019] The following are its main beneficial effects: (1) By quantifying individual real-time cognitive abilities as thread capacity parameters and integrating the global constraints of the task feature map, the system achieves a precise match between multi-task combinations and individual cognitive resources. Compared with the static assignment method, this method completely solves the problem of low test validity caused by ignoring cognitive resource fluctuations, and enables the generated task combinations to truly reflect the user's current cognitive state.

[0020] (2) Graph embedding technology is used to analyze the directional competition between attention, working memory, and executive control resources. Combined with directional conflict simulation on Riemannian manifolds, this approach overcomes the difficulty of quantifying multi-task resource preemption, which is a problem that traditional methods cannot solve. The generated task combinations avoid cognitive overload and significantly reduce operational risks in high-risk work scenarios.

[0021] (3) By integrating dynamic features such as task switching delay and interrupt recovery through timing conflict analysis, the generated test combination accurately simulates the timing pressure of real-world work scenarios. Compared with traditional solutions, the reliability of work performance prediction is greatly improved, which is particularly suitable for special occupations such as pilots who need to deal with unexpected situations. BRIEF DESCRIPTION OF THE DRAWINGS

[0022] Figure 1 A flowchart of a multi-task automated question matching method provided in an embodiment of the present application; Figure 2 This is a structural block diagram of a multi-task automated question-matching system provided in an embodiment of the present application. DETAILED DESCRIPTION

[0023] Example 1: Reference Figure 1 , is a flow chart of a multi-task automated question matching method provided by an embodiment of the present invention. The flow may include at least steps S100-S600: S100, collecting real-time behavioral data in a multi-task test, performing data cleaning and feature extraction, and obtaining standardized behavioral data; S200, constructing a cognitive task feature map, performing node embedding and relationship modeling, and obtaining an initial cognitive map; S300, dynamically calculating thread capacity thresholds based on standardized behavior data, performing personalized resource allocation modeling, and obtaining dynamic thread capacity parameters; S400: Fusing the dynamic thread capacity parameter with the initial cognitive map to predict cognitive conflict and generate a conflict intensity index; S500, screening the safety task combination according to the conflict intensity index, performing multi-task sequence optimization, and generating a multi-task test instruction set; S600: Execute the multi-task test instruction set and establish a real-time feedback link to perform dynamic data collection and model update.

[0024] Step S100 at least includes steps S110-S130: S110 , during the test execution process, collecting the user's multi-task operation log and real-time behavior data, and obtaining response delay data and error rate data.

[0025] During the test execution process, the system captures the user's multi-task operation logs and real-time behavior data in real time through the embedded data acquisition module. Specifically, the embedded data acquisition module is integrated in the event scheduling layer of the test engine, and uses an event-driven architecture to monitor user interaction events. When the user starts to execute a combination of multiple tasks, the system records the task start timestamp; when the user performs a task switching operation, the system captures the end time of the previous task and the start time of the next task; when a task interruption event is triggered, the system marks the time when the interruption occurs and the time of recovery. For each task instance, the system collects two types of core data: response delay data, that is, the time interval from the presentation of the task instruction to the user's effective response, accurate to milliseconds; error rate data, that is, the deviation rate between the user's operation result and the standard answer, which is statistically calculated according to the task type.

[0026] The response delay data includes simple reaction time data, choice reaction time data and complex decision time data, which correspond to different cognitive processing levels respectively.

[0027] The error rate data covers three categories: operation error rate, judgment error rate and logic error rate. Each type of error rate is classified and marked using an error type coding table.

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

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

[0030] The original behavioral dataset serves as the input source for the time series alignment process.

[0031] S120: Perform time series alignment processing on the response delay data and the error rate data to generate a behavior sequence with synchronized timestamps.

[0032] The system receives the original behavioral data set from S110 and first performs time base unification processing. Specifically, the network time protocol is used to synchronize the system clocks of all data acquisition terminals to eliminate clock deviations between devices. For the response delay data and error rate data, a dual-channel time axis mapping mechanism is established: the response delay channel uses the task presentation time as the time origin, and the error rate channel uses the user operation submission time as the time origin. The data of the two channels are mapped to a unified time base axis through the time axis normalization algorithm to eliminate timing offset. Furthermore, dynamic time warping technology is used to align the time series data of different types of tasks: for multi-task data, a 500-millisecond fixed window is used for segmented aggregation; for task switching data, an event-triggered adaptive window is used, and the window size is dynamically adjusted according to the duration of the previous task; for task interruption data, an 800-millisecond fixed window is set to cover the 400-millisecond interval before and after the interruption. During the time axis alignment process, the system attaches an accurate timestamp to each data point, and the timestamp format is Unix millisecond timestamp.

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

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

[0035] The behavior sequence is stored in a time series database, and its time synchronization accuracy is controlled within ±5 milliseconds to ensure the time series consistency of subsequent feature extraction.

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

[0037] S130 , extracting task switching delay features and concurrent error features from the behavior sequence, performing data cleaning and feature extraction, and obtaining standardized behavior data.

[0038] 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: the first stage, based on the interquartile range method, eliminates data points with response delays less than 0.5 times the first quartile or greater than 1.5 times the third quartile; the second stage, based on the task type baseline, filters data points that exceed the historical maximum delay value of similar tasks; and the third stage, based on a dynamic threshold, removes data points where three consecutive sampling points deviate from the moving mean by three times the standard deviation. During the data cleaning process, the system maintains an abnormal data log, recording the original information of the eliminated data and the reasons for elimination. After completing the data cleaning, the system performs feature extraction operations: for the task switching delay feature, the response time difference within each 200 millisecond window before and after the task switching point is calculated to extract four features: switching delay mean, switching delay variance, maximum switching delay, and switching delay change gradient; for the concurrent error feature, the operation sequence during the execution of multiple tasks is analyzed to extract three features: concurrent error density, cross-task error correlation, and error propagation intensity. Feature extraction utilizes a sliding window statistical method, with window sizes consistent with those in S120: a 500-millisecond window for multitasking sections, a 300-millisecond window for task switching points, and an 800-millisecond window for task interruption zones. All feature extraction algorithms are implemented in a feature computation engine, which utilizes a streaming architecture to process behavioral sequence data in real time. Feature data is normalized using a Z-score to conform to a standard normal distribution with a mean of 0 and a standard deviation of 1. The standardized behavioral data comprises a seven-dimensional feature vector: switching delay mean, switching delay variance, maximum switching delay, switching delay gradient, concurrent error density, cross-task error correlation, and error propagation strength. This standardized behavioral data is stored in a feature repository and serves as input to two downstream modules: the S300 dynamic thread capacity assessment module for calculating thread capacity thresholds; and the S210 cognitive map construction module as task feature supplementation. This standardized behavioral data is pushed to downstream processing modules in real time via a message queue, forming a closed-loop data processing chain.

[0039] Step S200 at least includes steps S210-S230: S210: Extracting operation type features, resource requirement features, and difficulty level features of the task from a preset cognitive task library.

[0040] The system accesses a library of pre-set cognitive tasks and uses a feature extraction engine to obtain three-dimensional feature data for each task. Specifically, the library is stored in a distributed graph database and contains multiple cognitive task definition files. For the operation type feature, the system uses a rule-based feature mapping algorithm: it reads the task description text, matches it to a pre-defined keyword table (e.g., "direction recognition" is mapped to the navigation category, and "radio interaction" is mapped to the communication category), and outputs a discrete operation type code. For the resource requirement feature, the system uses a five-level quantitative scale: by parsing the cognitive load description in the task design document, it quantifies "low attention demand" as level 1 and "high working memory demand" as level 5, thereby forming a resource requirement vector. For the difficulty level feature, the system uses an adaptive difficulty calibration algorithm: combining historical task completion rates and error distribution data, it generates a continuous difficulty value with a precision of 0.1 based on the pre-set beginner / intermediate / advanced levels. During the feature extraction process, the system receives standardized behavioral data from S130 as supplementary input and incorporates task switch latency variance and concurrent error density features into the resource requirement assessment model to enhance the individual adaptability of the feature representation. The feature extraction engine outputs a structured feature dataset containing a triplet of features for each task: an operation type code, a resource requirement vector, and a difficulty level value.

[0041] S220: Encode the operation type feature, resource requirement feature, and difficulty level feature as graph node attributes.

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

[0043] S230. Construct edge connections based on the overlapping relationship of cognitive abilities between tasks, perform node embedding and relationship modeling, and obtain an initial cognitive map.

[0044] The system receives the node attribute dataset generated by S220 and creates a cognitive task feature map using 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, and the resource requirement vectors are compared using the cosine similarity algorithm. Strong edges are established between nodes with a similarity exceeding 0.7. Second, the complementarity of operation types is detected, and weak edges are established for operation types that need to be used alternately (such as navigation and communication). Finally, a progressive difficulty relationship is introduced, forming a hierarchical connection chain according to the difficulty level. The edge connection construction adopts a three-stage weighting mechanism: the weight of strong connection edges is set to 1.0, the weight of weak connection edges is set to 0.5, and the weight of hierarchical connection edges is set to 0.8. In the relationship modeling stage, the system uses a graph embedding algorithm to process nodes and edges: random walk sampling is performed using the Node2Vec model, with a walk length of 10 and a number of walks of 100. Node embedding representations are learned using the Skip-gram model to generate 128-dimensional node embedding vectors. Edge relationships are modeled using the TransE model, mapping edge types to relationship vectors. The graph embedding process produces two outputs: a node embedding matrix storing vector representations of all tasks, and an edge relationship tensor storing connection types and weights. The initial cognitive graph is stored as a graph data structure, consisting of a node set (task ID + embedding vector), an edge set (connection type + weight), and global attributes (graph version identifier). This initial cognitive graph serves as the input vector for module S410, and its node embedding vectors are directly used for graph neural network message passing in S420.

[0045] Step S300 at least includes steps S310-S330: S310: Obtain standardized behavior data, and calculate the error rate change gradient and switching delay increment during task concurrency.

[0046] The system receives standardized behavioral data from S130 and processes the multidimensional feature vectors using the thread capacity calculation engine. Specifically, the standardized behavioral data includes seven features: switching delay mean, switching delay variance, maximum switching delay, switching delay gradient, concurrent error density, cross-task error correlation, and error propagation strength. To calculate the error rate gradient, the system employs a time window partitioning mechanism: The concurrent process is divided into five equal-length time periods, based on the starting point of task concurrency. Within each time period, the concurrent error density feature is extracted, and the local change rate is calculated by the difference in error density between adjacent time periods. Finally, a weighted average algorithm is used to integrate these local change rates, assigning weights based on the proportion of time period lengths, to generate the overall error rate gradient. To calculate the switch delay increment, the system performs a double comparison operation: first, the mean difference in switching delays between multi-task and single-task states is compared to obtain the absolute increment; second, the change in switching delay variance between adjacent switching points in the task switching sequence is analyzed to calculate the variance growth ratio. During the calculation, the system introduces a time decay factor to give greater weight to recent behavioral data, enhancing the model's sensitivity to the current cognitive state. The thread capacity calculation engine outputs structured calculation results: a scalar value of the error rate change gradient and a three-dimensional vector of the switching delay increment (absolute increment value, variance growth value, peak offset), forming a primary parameter set for thread capacity calculation.

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

[0048] The system receives the initial parameter set generated in S310 and performs curve fitting using a cognitive decay modeler. Specifically, a two-channel collaborative modeling architecture is employed: the first channel processes the error rate gradient and maps it into an indicator of cognitive resource consumption rate; the second channel processes the three-dimensional vector of handover delay increments and converts it into an indicator of cognitive resource allocation efficiency. The cognitive decay modeler employs a piecewise function fitting strategy: linear fitting is used in the initial phase of task concurrency (0-3 seconds) to model rapid resource consumption; logarithmic fitting is used in the stable phase (3-8 seconds) to simulate a continuous resource decay pattern; and exponential fitting is applied in the critical phase (>8 seconds) to predict the resource depletion inflection point. For the error rate channel, the system establishes a gradient-decay mapping table: an error rate gradient less than 0.1 is marked as slow decay, 0.1-0.3 as moderate decay, and greater than 0.3 as rapid decay. For the handover delay channel, the system performs a vector synthesis operation: the absolute increment value, variance growth value, and peak offset are combined using a weighted fusion formula to generate a comprehensive delay coefficient. The coefficient is positively correlated with the intensity of cognitive resource competition. The curve fitting process incorporates a personalized calibration mechanism: Based on the user's best performance records from historical test data, an individual baseline decay model is established. The current fitted curve is compared with the baseline model to generate a deviation parameter. The fitted cognitive resource decay curve is stored as a parameterized equation, containing three core features: slope parameter, inflection point coordinates, and asymptote value.

[0049] S330 : 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.

[0050] The system receives the parameterized decay curve equation output in S320 and calculates the thread capacity threshold through a resource allocation optimizer. Specifically, a critical point detection algorithm is used: the decay curve is scanned for critical locations where the curvature change rate exceeds a preset threshold. The time point corresponding to this location is the maximum sustainable duration. The sustainable duration is then converted into the equivalent number of threads based on the time-to-thread conversion formula of thread cognition theory. The resource allocation optimizer performs a three-stage optimization: the first stage applies a capacity upper limit constraint, setting the initial maximum number of threads to 5; the second stage performs a decay compensation calculation. When the slope of the curve exceeds 0.2, the compensation mechanism is activated, reducing the number of equivalent threads by 0.5 for every 0.1 increase in the slope value; the third stage applies individual difference correction, referring to the concurrent error density characteristic value in S130. For every 0.1 unit increase in error density, the thread capacity is reduced by 0.2. During the modeling process, the system constructs a multidimensional resource allocation matrix: cognitive resources are divided into three categories: attention resource slots, working memory slots, and executive control slots, and weights are assigned to each slot based on the resource demand characteristics extracted in S210. The personalized resource allocation model outputs dynamic thread capacity parameters, which contain a three-dimensional vector: the total thread capacity value, the capacity distribution vector of each resource slot, and the capacity confidence coefficient. The dynamic thread capacity parameters are encapsulated in JSON format and pushed to the S410 module in real time for injection into the global node of the cognitive map.

[0051] Step S400 at least includes steps S410-S430: S410: Inject the dynamic thread capacity parameter into the global attribute node of the initial cognitive graph.

[0052] The system receives dynamic thread capacity parameters from S330 and integrates them with the initial cognitive graph through the graph injection engine. Specifically, the dynamic thread capacity parameters consist of a three-dimensional vector: total thread capacity value, capacity distribution vector for each resource slot, and capacity confidence coefficient. The initial cognitive graph is obtained from the S230 module. 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, mapping the total thread capacity value to a scalar of the total global cognitive resource amount; the second stage decomposes the resource slot distribution vector, converting the capacity values of the attention resource slot, working memory slot, and execution control slot into normalized coefficients in the range of 0-1; the third stage establishes association rules between capacity parameters and graph nodes, matching the weight allocation of corresponding resource slots based on the resource demand characteristics extracted in S210. During the injection process, the system creates a new global attribute node, which stores four attributes: total capacity scalar, attention coefficient, memory coefficient, and control coefficient. The global attribute node establishes virtual edges with all task nodes through a bidirectional connection mechanism. The virtual edge weights are dynamically calculated based on the resource demand characteristics encoded by the task nodes in S220. The cognitive graph that has been injected is added with a global capacity feature layer. The graph version identifier is updated synchronously, and the capacity parameter injection timestamp and parameter fingerprint are annotated.

[0053] S420. Use the graph neural network to perform multiple rounds of message transmission on the injected cognitive graph to predict the cognitive resource competition intensity of the task combination.

[0054] The system receives the injected cognitive graph output by S410 and performs multiple rounds of message passing through a graph neural network analyzer. Specifically, the graph neural network employs a three-layer graph convolutional architecture: the first layer processes node features, concatenating a 128-dimensional node embedding vector with a global capacity parameter to produce 132-dimensional input features. The second layer processes edge features, constructing adjacency matrices based on the three edge types defined in the edge set: strong connections (weight 1.0), weak connections (weight 0.5), and hierarchical connections (weight 0.8). The third layer integrates virtual edge features, treating virtual edges between global attribute nodes and task nodes as special connection channels. The message passing mechanism comprises three core operations: a message generation phase, in which each task node generates an attention resource request signal, a working memory occupancy signal, and an executive control request signal based on a resource demand vector; a message aggregation phase, in which signals sent by neighboring nodes are aggregated using a weighted summation algorithm, with weights determined by edge type (strong connections have a coefficient of 1.0, weak connections have a coefficient of 0.5, and virtual edges have a coefficient of 0.3); and a node update phase, in which a gated recurrent unit fuses historical states with aggregated messages to generate a new node state vector. This multi-round message passing process is repeated over a fixed five-round iteration: the first two rounds focus on direct resource competition between task nodes, while the last three rounds introduce global capacity constraints to simulate resource redistribution. In the final round, the system outputs a task combination competition intensity matrix: for each possible multi-task combination (containing 2-4 tasks), the difference between the sum of the resource requirements of the nodes in the combination in the attention slot, memory slot, and control slot and the global capacity coefficient is calculated. The Euclidean distance of these three differences is used as the raw competition intensity value.

[0055] S430: Output a conflict intensity index according to the cognitive resource competition intensity to generate a conflict intensity index.

[0056] The system receives the task combination competition intensity matrix output by S420 and generates a standardized indicator through a conflict quantizer. Specifically, the conflict quantizer performs a four-step processing flow: the first step is intensity normalization, linearly converting the original competition intensity value to the range of 0-1, and the conversion formula is (actual value-minimum intensity value) / (maximum intensity value-minimum intensity value); the second step introduces capacity confidence compensation, adjusting the indicator 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, applying a 1.2x pressure coefficient to multiple task combinations, a 1.0x coefficient to task switching combinations, and a 0.8x coefficient to task interruption combinations; the fourth step performs timing conflict superposition, and for combinations containing task switching or interruption, increases the competition intensity increment value of adjacent task switching points. The conflict intensity indicator is a floating-point scalar stored in the task combination conflict library. Each entry contains four attributes: combination ID (the sequence of task IDs included), conflict intensity value, resource competition type tag, and update timestamp. The indicator generation process establishes a version association mechanism, binding the conflict intensity value to the S410 map version identifier to ensure traceability. The generated conflict intensity indicator is pushed to the S510 module through the message queue and serves as the core input parameter for the safety task combination screening.

[0057] In another embodiment, S410: Improved Hamiltonian-Chebyshev spectrum injection model.

[0058] The system receives dynamic thread capacity parameters from S330 ,in Represents a scalar value of total thread capacity, represents the capacity distribution vector of the three resource slots of attention / memory / executive control, Represents the capacity confidence coefficient. Initial cognitive map Obtained from the S230 module, where is the task node set of the cognitive graph, including task nodes, each with a 128-dimensional embedding vector ( ), is the edge set of the cognitive graph.

[0059] Construct a global attribute node injection function: in: : global attribute node vector; Total capacity normalization function; : resource slot distribution normalization function; represents the capacity confidence coefficient; Furthermore, the virtual edge weight generation formula is: in: : virtual edge weight; : resource requirement vector of task node i; : resource requirement vector of task node k; : The second component of (resource slot coefficient); : The total number of task nodes in the graph; Technical implementation: The system performs three-stage operations through the graph injection engine. First, parse Parameters, apply formula 1 to generate four-dimensional global properties Then create virtual edges connecting all task nodes and global nodes, and use formula 2 to calculate the weight of each virtual edge. The final output enhanced atlas ,in Represents the newly added virtual edge set.

[0060] The system receives the dynamic thread capacity parameters generated by the S330 module, which include the total thread capacity value, the capacity distribution vectors of the 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 it to the numerical range of the cognitive graph; second, the resource slot capacity distribution vector is converted into a proportional coefficient to maintain the relative relationship between each resource type; finally, the processed parameters are fused with the initial cognitive graph. During the fusion process, the system creates a global attribute node storage capacity parameter and establishes a dynamic association between the node and all task nodes through a virtual edge connection mechanism. The weight value of the virtual edge is generated by calculating the matching degree between the task node resource demand and the global resource slot coefficient, and finally outputs the enhanced cognitive graph structure.

[0061] S420: Improved Riemannian Manifold Graph Convolutional Network Define the initial state of the node: in, : node initial state vector; is the 128-dimensional node embedding vector of S230; Represents a vector concatenation operation.

[0062] Furthermore, the Riemannian manifold message passing function is constructed: in: : No. The message vector of the layer; : Sigmoid activation function; : The neighbor set of node i; : 2D rotation matrix; : resource demand vector angle (radians); : The connectivity of node i (number of adjacent nodes); 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), and GRU is gated recurrent unit.

[0063] 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 Take the edge weight from S230; 2) Update the node status according to formula 5. Finally, output the stable state of all nodes .

[0064] Based on the enhanced graph output by S410, the system initializes the node state vector of the graph neural network, which is composed of the original node embedding features and the global attribute node parameters. During the message passing phase, an improved neighbor information aggregation strategy is adopted: the resource demand direction differences between different task nodes are processed through rotation matrices, degree normalization is used to eliminate network topology deviations, and a gating mechanism is introduced to dynamically fuse historical states with global constraints. After five rounds of iterative calculations, each task node generates a state vector containing the latest resource competition information. The key innovation of this module is to model the spatial distribution characteristics of cognitive resources as geometric transformations on a Riemannian manifold, thereby more accurately simulating the resource competition dynamics in a multi-task environment.

[0065] S430: Improved Shannon Entropy-Monte Carlo Conflict Quantification Task combination ( ), computing resource competition tensor: in, : Resource competition tensor; : the attention resource requirements of task k; : global attention capacity; : Working memory requirements of task k; : global working memory capacity; : Execution control requirements of task k; : Global execution control capacity; Furthermore, the Shannon entropy conflict measure is constructed: in, : Shannon entropy conflict measure; : Resource slot type index, A=attention, M=working memory, E=executive control; is the normalized competition intensity ratio of task combination K on resource slot s; Final conflict intensity generation: in: : Final conflict intensity index; : Task switching time variance; : Task type coefficient (multitasking 1.2, switching 1.0, interrupt 0.8); : Timing conflict weight coefficient; Technical implementation: The system traverses all possible task combinations (approximately For each combination: 1) calculate resource contention according to Formula 6; 2) calculate entropy according to Formula 7; 3) generate conflict intensity according to Formula 8 The result is stored in the conflict library, which contains four tuples. .

[0066] The system traverses all possible task combinations and performs a three-level quantitative analysis for each combination. First, the difference between the cumulative demand for the three resource slots by each task within the combination and the global capacity is calculated to generate a resource contention tensor. Second, the tensor value is converted into a probability distribution and the Shannon entropy is calculated to quantify the degree of uncertainty in resource contention. Finally, the entropy value, capacity confidence, task switching time characteristics, and task type coefficient are integrated to generate a standardized conflict intensity index. During this process, the node status output by S420 provides real-time resource demand data, the time series characteristics recorded by S120 enhance timing conflict assessment, and the capacity confidence parameter of S330 ensures the reliability of the index. All calculation results are stored in a conflict knowledge base, providing decision-making basis for downstream modules.

[0067] Step 500 at least includes steps S510-S530: S510 , obtaining a conflict intensity index, filtering task combinations whose conflict intensity exceeds a preset threshold, and obtaining a safe task combination set.

[0068] The system receives the conflict intensity indicator dataset from S430 and performs safe combination screening using a conflict filter. Specifically, the conflict intensity indicator dataset is stored in a task combination conflict library, where each entry contains four attributes: combination ID, conflict intensity value, resource contention type flag, and update timestamp. The conflict filter first loads a preset conflict threshold, which is adaptively set based on the dynamic thread capacity parameter in S330: 0.3 when the total thread capacity is greater than 4.0, 0.25 when the capacity is between 3.0 and 4.0, and 0.2 when the capacity is less than 3.0. The filtering operation is performed in three steps: the first step is to iterate through all entries in the conflict library and mark combinations with conflict intensity values exceeding the threshold; the second step is to verify the resource contention type, adding an additional threshold tolerance of 0.05 to combinations marked as "attention-dominant contention"; and the third step is to perform timeliness verification, eliminating combinations with update timestamps older than the most recent graph injection time in S410. During the filtering process, the system establishes a dynamic exclusion mechanism: if a task ID is marked as high conflict in more than 50% of the combinations, the task is added to a temporary ban list. The filtering operation generates a set of security task combinations, which contains three metadata items: combination ID sequence, maximum conflict strength value, and available resource slot distribution. The set of security task combinations is stored in a temporary workspace of the graph database, and its data structure maintains a mapping relationship with the node ID of the initial cognitive graph in S230.

[0069] S520 , selecting a multi-task combination, a task switching combination, and a task interruption combination from the safety task combination set.

[0070] The system receives the safe task combination set generated in S510 and performs classification extraction through a task selector. Specifically, a graph-based traversal algorithm is employed: first, multiple task combinations are identified, and combinations containing at least two concurrent task nodes are screened from the safe set. These nodes must meet the complementary resource requirement characteristics defined in S220 (e.g., pairs with high attention requirements and low working memory requirements). Second, task switching combinations are retrieved, selecting combinations containing three or more nodes and possessing hierarchical edge identifiers from S230. Finally, task interruption combinations are located, searching for node combinations with an "interruption recovery flag," which is derived from the concurrent error feature analysis results from S130. The selector performs priority sorting: multiple task combinations are sorted in descending order by the number of concurrent tasks; task switching combinations are sorted in ascending order by the length of the switching path (the time series span defined in S120); and task interruption combinations are sorted in descending order by the interruption recovery efficiency value (calculated based on the error propagation intensity from S130). During the selection process, the system implements load balancing: multiple task combinations do not exceed 40% of the total selection, task switching combinations account for 40%, and task interruption combinations account for 20%. The final output of the three-category combination set contains complete graph information: each combination carries the node embedding vector (from S230), the edge connection weight (from the S420 message passing result) and the conflict intensity history (from S430).

[0071] S530: Arrange the timeline and balance the difficulty of the selected three types of task combinations, optimize the multi-task sequence, and generate a multi-task test instruction set.

[0072] The system receives the classification combination set output by S520 and generates test instructions through the sequence optimization engine. Specifically, the arrangement process is divided into two dimensions: on the time axis dimension, the interval parameters are set according to the statistical laws of the S120 time synchronization behavior sequence - the deviation of the start time of each task in the multi-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; and the interruption trigger point of the task interruption combination is set within the range of ±10% of the mid-task duration. On the difficulty balance dimension, the difficulty level feature of S210 is called to perform three-level adjustments: first, the overall difficulty mean of the combination is calculated and constrained to the ability range reflected by the user's 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. When it is detected that the S310 switching delay increment is lower than the historical average, the difficulty of the subsequent task is increased by 0.1 level. The sequence optimization utilizes an iterative genetic algorithm: the initial population size is 200 sequences, and the fitness function integrates conflict strength (weighted 0.6), difficulty gradient (weighted 0.3), and time efficiency (weighted 0.1). 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 (concurrency / switching / interruption), the middle layer describes the task ID sequence and timing parameters, and the bottom layer embeds S220 node attribute data. This instruction set is transmitted to the S610 test engine via an encrypted channel, and its data structure includes the interface specifications for the S620 feedback link.

[0073] Step S600 at least includes steps S610-S630: S610: Load a multi-task test instruction set, and execute a sequence of concurrent tasks, switching tasks, and interrupt tasks in a test engine.

[0074] The system receives a multi-task test instruction set from S530 and parses the instruction structure through a 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 / switch sequence / interrupt sequence), a total duration threshold, and a resource usage warning value; the middle layer defines the task ID sequence and time control parameters, including a concurrent task start time deviation threshold (≤200 milliseconds), a task switch interval coefficient (1.2 times the previous task duration), and an interrupt trigger time window (±10% of the mid-task duration); the bottom layer embeds S220 node attribute data, including an operation type code, a resource requirement vector, and a difficulty level value. The test loader activates the corresponding execution mode based on the sequence type: for concurrent sequences, all task instances in the instruction set are synchronously launched, and a thread allocator is used to ensure that each task runs in an independent thread; for switch sequences, a task queue stack is constructed, and task rotation is automatically triggered based on a preset switch interval coefficient; for interrupt sequences, an interrupt monitor is deployed while the main task thread is running in the background, injecting interrupt events when the system time enters the preset interrupt time window. The event scheduling layer of the test engine adopts a priority queue mechanism: interrupt tasks have the highest priority, switching tasks are second, and concurrent tasks have the basic priority. All task instances call the operation type processing logic defined in S210 when executing and are constrained by the dynamic thread capacity parameters in S330.

[0075] S620: Record the user's real-time operation behavior during the execution process and establish a real-time feedback link.

[0076] During the test engine's execution, the system collects real-time operational behavior data through distributed probes. Specifically, these distributed probes are deployed at three key collection points: the task presentation module records task start timestamps, the response capture module records the time and content of user operation submissions, and the interrupt handling module marks the time of interruption occurrence and recovery. The collected data includes four core categories: response latency (the time difference between task presentation and operation submission), operation result data (the matching status between user input and standard answers), task state transition data (start / switch / interrupt / termination events), and resource usage data (memory and CPU usage). The feedback link is established using a dual-channel architecture: the primary channel transmits behavioral data in real time via WebSocket, transmitting packets every 200 milliseconds containing a five-tuple consisting of task ID, operation type, timestamp, response value, and result status. The secondary channel stores detailed operation traces in a log buffer queue, adding millisecond timestamps according to the time synchronization specifications defined in S120. The real-time operational behavior dataset is stored using the same JSON structure as S110, with a new resource usage field added for subsequent thread capacity analysis. Integrity verification is implemented during the data collection process: after each task sequence (concurrency / switching / interruption) is completed, the system automatically compares the number of collected data points with the expected number of operation steps. If the missing rate exceeds 5%, the data retransmission mechanism is triggered.

[0077] S630: Input the real-time operation behavior into the standardized behavior data collection process to perform dynamic data collection and model update.

[0078] The system injects the real-time operational behavior dataset collected by S620 into a standardized processing pipeline. Specifically, this standardized processing pipeline comprises three stages: the first stage performs data format conversion, mapping the raw JSON-formatted behavior data into a five-attribute structure defined by S120 (standardized timestamp, task type code, response delay value, error rate value, and task status flag). The second stage invokes S130's data cleansing process, employing the same three-stage outlier processing mechanism: initial screening based on the interquartile range method, baseline filtering based on task type, and dynamic threshold elimination. The third stage performs feature regeneration, re-extracting task switching delay features and concurrency error features using S130's sliding window statistical method to generate new standardized behavior data. Model updates utilize an incremental learning mechanism: newly generated standardized behavior data is appended to the S130 feature repository, triggering three types of model updates: S300 thread capacity model incremental training, which uses the new data to update the cognitive resource decay curve parameters; S420 graph neural network model fine-tuning, which optimizes message passing weights based on new conflict samples; and S510 security portfolio screening model calibration, which dynamically adjusts the conflict threshold based on the latest behavior data. When the dynamic data collection is completed, a version update identifier is generated, and the identifier is synchronized to the S410 global attribute node to ensure the consistency of the cognitive map version of the entire system.

[0079] Example 2: Figure 2 FIG. 1 shows a structural block diagram of a multi-task automatic assignment system according to an embodiment of the present invention. Figure 2 As shown, the structure may include: The real-time behavior collection module 10 collects the real-time behavior data in the multi-task test, performs data cleaning and feature extraction, and obtains standardized behavior data.

[0080] Embedded data capture: integrated into the test engine event scheduling layer, it monitors user interaction events in real time through an event-driven architecture, and collects multi-task start timestamps, task switching intervals, interrupt event markers, and recovery times.

[0081] Core data collection: Response latency data (the time difference between task presentation and effective response) and error rate data (the deviation rate between the operation result and the standard answer) are obtained and stored as JSON-formatted logs by task type. These logs contain a five-tuple consisting of task ID, type, timestamp, response value, and result status.

[0082] Data preprocessing: Raw data is transmitted to the central processing node in real time via the WebSocket protocol, providing an input source for time series alignment.

[0083] The cognitive map construction module 20 executes the construction of cognitive task feature map, performs node embedding and relationship modeling, and obtains the initial cognitive map.

[0084] Feature extraction engine: parses operation type features (classification codes such as navigation / communication / troubleshooting), resource requirement features (five-level quantitative vectors of attention / working memory / executive control), and difficulty level features (0.1 precision continuous values based on historical completion rates) from a preset cognitive task library.

[0085] Node attribute encoding: A hierarchical encoding technique is used to convert features into graph node attribute vectors (8-dimensional one-hot encoding of operation type + 3-dimensional normalization of resource requirements + 1-dimensional segmented encoding of difficulty), which are then reduced to 5 dimensions through principal component analysis.

[0086] Relationship modeling: Based on the overlap of cognitive abilities, three types of edge connections are constructed (strong connections with resource similarity > 0.7, weak connections with complementary operation types, and hierarchical connections with increasing difficulty). 128-dimensional node embedding vectors and relationship tensors are generated through the Node2Vec and TransE models.

[0087] The thread capacity modeling module 30 dynamically calculates the thread capacity threshold based on the standardized behavior data, performs personalized resource allocation modeling, and obtains dynamic thread capacity parameters.

[0088] 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).

[0089] 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).

[0090] 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.

[0091] 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.

[0092] 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.

[0093] 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.

[0094] 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.

[0095] 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.

[0096] 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").

[0097] 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.

[0098] 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.

[0099] The test execution and feedback module 60 executes the multi-task test instruction set and establishes a real-time feedback link to perform dynamic data collection and model update.

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

[0101] Real-time behavior recording: Distributed probes collect four types of data (response latency, operation results, state transitions, and resource usage), and dual-channel transmission ensures integrity (WebSocket real-time packets + log buffer queue).

[0102] Closed-loop update: Inject new behavioral data into the standardized pipeline, triggering three types of incremental updates (thread capacity model refitting, graph neural network fine-tuning, and dynamic calibration of conflict thresholds), and synchronously updating the graph version identifier.

[0103] Obviously, the embodiments described above are only some of the embodiments of the present application, rather than all of the embodiments. The preferred embodiments of the present application are given in the accompanying drawings, but they do not limit the patent scope of the present application. The present application can be implemented in many different forms. On the contrary, the purpose of providing these embodiments is to make the understanding of the disclosure of the present application more thorough and comprehensive. Although the present application has been described in detail with reference to the aforementioned embodiments, for those skilled in the art, it is still possible to modify the technical solutions described in the aforementioned specific embodiments, or to make equivalent replacements for some of the technical features therein. Any equivalent structure made using the contents of the present application specification and the accompanying drawings, directly or indirectly used in other related technical fields, is also within the scope of 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 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: 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: Dynamically calculate thread capacity thresholds including: 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; The maximum number of sustainable threads is determined based on the cognitive resource decay curve, and personalized resource allocation modeling is performed to obtain dynamic thread capacity parameters.

5. 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.

6. 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.

7. 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.

8. 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.

9. 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.

10. A multi-task automated question matching system, used to implement the method according to any one of claims 1 to 9, 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