Customized task initiation method

Abstract

The present application relates to the technical field of task management, in particular to a task initiation method based on self-definition, comprising the following steps: collecting historical interaction logs to extract attribute sequences and node identifiers, screening initiation conditions to generate rule templates, constructing a four-dimensional tensor model, slicing to obtain two-dimensional columns, calculating the barycentric offset to determine the process connection and construct a directed graph, extracting node boundary parameters to identify mutually exclusive edges, and reconstructing paths to generate process information.In the present application, historical task interaction logs are extracted, an attribute reach matrix is constructed, and an attribute time sequence retention vector is calculated, the process connection type is determined by comparing the numerical density barycentric offset and the node sequence difference, and the path execution logic is reconstructed according to the conflict area range, which can effectively solve the problems of structure repetition, parameter configuration dispersion and uncontrollable execution path conflict in the traditional task initiation process, and realize efficient generation and reasonable configuration of the task process.

Description

Technical Field

[0001] This invention relates to the field of task management technology, and in particular to a custom task initiation method. Background Technology

[0002] Task management technology involves the systematic processing and scheduling of the entire process of task creation, allocation, execution, and completion. Specifically, it includes task definition and modeling, task status tracking and updating, task flow control and orchestration, task priority setting, management of inter-task dependencies, task-resource mapping and scheduling, and feedback recording and exception handling during task execution. This technology is widely used in enterprise project management, software development process management, manufacturing scheduling systems, and collaborative office platforms. Its core function is to improve task processing efficiency, ensure the orderly execution of task processes, and support collaborative task operations with multiple users.

[0003] Traditional custom-based task initiation methods refer to a task management system where users autonomously set task generation conditions through preset parameters or rule templates, triggering task creation accordingly. This method primarily addresses the lack of flexible configuration capabilities in the task initialization phase. Traditional methods typically involve manually selecting the task type, manually inputting task parameters, or retrieving settings from fixed templates to initiate a task. In these methods, users must specify the task's execution objective, target audience, time requirements, and approval process, among other details. The task management system then constructs a task record based on these parameters and injects it into the task flow for scheduling. Some systems also support automatic parameter filling based on predefined rules, but users still need to manually confirm or operate to complete the final task generation. While this type of method introduces a degree of customization, it still relies on limited template logic and static input methods in terms of operational granularity, rule configuration scope, and the triggering mechanism of the initiation process. Summary of the Invention

[0004] To address the technical problems existing in the prior art, embodiments of the present invention provide a custom-based task initiation method, including the following steps:

[0005] S1: Collect historical task interaction logs, extract and bind attribute timestamp sequences and node identifiers, and construct an attribute sequential reach matrix;

[0006] S2: Calculate the average order of the attribute arrival matrix, count the time series stability frequency, generate a time series preservation vector, filter and combine the initiation condition priority items, and generate a task initiation rule template.

[0007] S3: Based on the task initiation rule template, initiate project definition, establish a basic column framework with start, initiator, approval, and end columns, encode the item type number, initiator role level value, approval node sequence and expected processing cycle to generate a fixed-length vector structure, and construct four-dimensional attribute mapping tensor information.

[0008] S4: Slice the four-dimensional attribute mapping tensor information to obtain two-dimensional attribute column slices, calculate the centroid offset direction, compare the difference between the centroid offset direction and the node order to determine the process connection type, and construct a directed graph of the task process.

[0009] S5: Extract the expected duration and maximum task overlap tolerance period from the directed graph of the task flow as node time sequence boundary parameters, perform bidirectional time sequence value difference judgment on the node edge pairs in the directed graph of the task flow to identify process mutual exclusion edges, aggregate conflict areas, reconstruct paths to generate custom task flow information.

[0010] As a further embodiment of the present invention, the attribute sequential reach matrix specifically comprises task instance index rows, attribute category mapping columns, and reach timing numerical elements; the task initiation rule template specifically comprises attribute triggering logic items, condition combination priority, and timing dependency constraint bits; the four-dimensional attribute mapping tensor information specifically comprises a column feature vector layer, an attribute coupling coefficient layer, and a spatial mapping index layer; the task flow directed graph specifically comprises a node connection topology, flow control weights, and path state transition points; and the custom task flow information specifically comprises logically equivalent path segments, timing conflict avoidance strategies, and node execution configuration tables.

[0011] As a further aspect of the present invention, the specific steps of S1 are as follows:

[0012] S101: Collect historical task interaction logs, perform regular expression matching and field segmentation on unstructured log data streams, remove invalid record items that are missing task numbers or operation instructions, extract a set of fields including the unique task identifier, operation type code and operation occurrence time, perform standardized format conversion on the operation time field to convert it into a long integer numerical format, and generate a structured task interaction record set.

[0013] S102: Call the structured task interaction record set, group and aggregate the record items according to the unique task identifier, extract the operation type code from each group of records as the task node identifier, synchronously extract the corresponding standardized time value, form a task attribute timestamp sequence, establish a corresponding index mapping relationship between the task node identifier and the task attribute timestamp sequence under the same task, and generate a time sequence node feature mapping table.

[0014] S103: Based on the time-series node feature mapping table, extract all unique task identifiers that are not repeated, define the matrix row dimension, identify independent task node identifiers, define the matrix column dimension, traverse the index mapping relationship corresponding to the task, obtain the timestamp value of the node attribute being referenced for the first time in the process, fill the timestamp value into the row and column intersection cells and pad zeros for unreached positions, and construct the attribute sequential reach matrix.

[0015] As a further aspect of the present invention, the specific steps of S2 are as follows:

[0016] S201: Call the attribute sequential access matrix, traverse the matrix column vectors, extract the data rows with non-zero attribute timestamps, perform pairwise time series comparisons on any two attribute columns, count the number of samples where the timestamp value of the preceding attribute is less than the timestamp value of the following attribute, calculate the ratio of the number to the total number of present samples, determine the directional dependency probability, and construct the attribute time series association graph.

[0017] S202: Based on the attribute temporal correlation graph, extract strong correlation edges whose directional dependency probability exceeds the preset stability benchmark value. For each attribute node, calculate its out-degree stability weight as the starting point of the temporal sequence and its in-degree stability weight as the ending point. Perform a weighted summation operation on the out-degree stability weight and the in-degree stability weight to quantify the temporal anchor point features of the attribute and generate a temporal preservation vector.

[0018] S203: Based on the time-preservation vector, sort the time-anchor feature values ​​of the attribute nodes in descending order, select the attribute whose feature value is located at the top preset quantile as the initiation condition priority, analyze the strong correlation edges between the initiation condition priority, establish a logical triggering link, convert the logical triggering link into a standardized structure including condition judges and logical connectors, and generate a task initiation rule template.

[0019] As a further aspect of the present invention, the method for setting the stability benchmark value is as follows: extract the directional dependency probabilities between all attribute pairs in the attribute time-series correlation graph, construct a set of probability values, calculate the arithmetic mean and standard deviation of the set of probability values, and perform a linear weighted summation operation on the arithmetic mean and the standard deviation by a preset multiple to obtain the stability benchmark value.

[0020] As a further aspect of the present invention, the specific steps of S3 are as follows:

[0021] S301: Activate the project initialization interface based on the trigger logic item in the task initiation rule template, instantiate four independent functional entity objects: start node, initiator node, approval node and end node, assign a unique memory address identifier and status register bit to each functional entity object, configure data transmission link and control signal interface between each functional entity object according to logical connector, and combine them to form the basic column topology architecture that carries the task flow logic.

[0022] S302: Call the basic column topology architecture, traverse each functional entity object, extract the item type number, initiator role level value, approval node numerical order and expected processing cycle parameter, call the preset character index dictionary to map the text parameters to discrete numerical index, perform linear scaling calculation on the numerical parameters, map them to unit interval, arrange the processed values ​​in a fixed order and fill them into an array container of preset dimensions, and generate a column attribute feature vector set;

[0023] S303: Obtain the set of feature vectors of the column attributes, construct a four-dimensional coordinate space including column source dimension, column destination dimension, attribute feature dimension and time evolution dimension, map the feature vectors to the corresponding grid positions in the four-dimensional coordinate space according to the topological connection relationship between columns, perform dot product operation on any two column vectors in the attribute feature dimension, quantify the attribute coupling strength and fill it into the corresponding coordinate point, and generate four-dimensional attribute mapping tensor information.

[0024] As a further aspect of the present invention, the specific steps of S4 are as follows:

[0025] S401: Call the four-dimensional attribute mapping tensor information, fix the attribute feature dimension and perform slice extraction along the time evolution axis to obtain two-dimensional attribute column slices, perform weighted moment operation on the coupling strength value in the slice matrix, locate the density centroid coordinates, calculate the Euclidean distance and azimuth angle of the density centroid coordinates relative to the geometric center of the slice, construct vector parameters representing the flow trend and intensity between columns, and generate column coupling centroid offset vector;

[0026] S402: Obtain the column coupling center offset vector, extract the preset node order value of the corresponding source column and destination column in the basic framework and calculate the algebraic difference, check the sign consistency between the projection component of the offset vector and the algebraic difference, if the signs are opposite, mark it as a reverse backtracking relationship, if the signs are the same, determine it as a direct serial or cross-stage parallel relationship based on the vector magnitude, and output the process connection type status information.

[0027] S403: Based on the process connection type status information, initialize the adjacency matrix structure of the directed graph, insert non-zero weights at the corresponding node index positions, create directed edges, add synchronous convergence gateway nodes for parallel relationship types, add feedback edges with conditional constraints for reverse backoff relationships, traverse the matrix to perform reachability detection, eliminate broken paths and dead loop paths, and generate a directed graph of the task flow.

[0028] As a further aspect of the present invention, the process of verifying the sign consistency of the projection component of the offset vector and the algebraic difference specifically involves calculating the cosine similarity projection value of the column coupling center offset vector in the direction of the preset time evolution axis, and extracting the sign value of the algebraic difference; performing a multiplication operation between the cosine similarity projection value and the algebraic difference; if the result is negative, it is determined that the center offset direction is contrary to the node temporal direction, and it is confirmed as a reverse backtracking relationship.

[0029] The process of determining whether a relationship is a direct serial or cross-stage parallel relationship based on the vector magnitude is as follows: the L2 norm of the column coupling centroid offset vector is calculated as the measured value of the magnitude, and the standard unit step size between adjacent nodes in the basic column framework is obtained; if the measured value of the magnitude is within the preset tolerance range of the standard unit step size, it is identified as a direct serial relationship; if the measured value of the magnitude exceeds the preset multiple threshold of the standard unit step size, it is identified as a cross-stage parallel relationship.

[0030] As a further aspect of the present invention, the specific steps of S5 are as follows:

[0031] S501: Call the directed graph of the task flow, traverse all task node entities in the graph structure, parse the internal attribute metadata, extract the preset standard task working hours and the maximum task overlap tolerance period, standardize the standard task working hours into the execution span of the time dimension, map the maximum task overlap tolerance period into the allowed time overlap deviation range, combine and bind the execution span and the time overlap deviation range and encapsulate them into the timing configuration field of the corresponding node to generate the node timing boundary parameters;

[0032] S502: Based on the node timing boundary parameters, calculate the earliest start time difference and the latest end time difference of adjacent node pairs in the directed graph, perform bidirectional timing offset calculation on the connection edges between nodes, obtain the actual interval value, compare the actual interval value with the time overlap deviation range, identify connection paths with an interval value less than zero and an absolute value exceeding the deviation range, mark the path as a logical connection relationship with non-parallel attributes and exclusive constraints, and generate process mutual exclusion edges;

[0033] S503: Based on the process of retrieving all mutually exclusive connection paths marked as exclusive in the directed graph, the local topology subgraph including mutually exclusive paths and their directly associated nodes is delineated by breadth-first search algorithm, the conflict area range is aggregated, mutually exclusive logical gateway entities are inserted in the conflict area and conditional branch routes are replanned to replace the original mutually exclusive connections, the logical completeness of the reconstructed full graph paths is checked and serialized and encoded for output, and a custom task flow definition is generated.

[0034] As a further aspect of the present invention, the process of performing bidirectional temporal offset calculations on the connection edges between nodes to obtain the actual interval value specifically involves: determining the predecessor and successor nodes based on the pointing relationship of the connection edges in the directed graph of the task flow; extracting the execution span from the node temporal boundary parameters corresponding to the predecessor node; adding the earliest start time of the predecessor node to the execution span to obtain the earliest end time of the predecessor node; calculating the difference between the earliest start time of the successor node and the earliest end time of the predecessor node to obtain the forward temporal relaxation; calculating the difference between the latest start time of the successor node and the latest end time of the predecessor node to obtain the reverse temporal relaxation; performing a minimization filtering operation on the forward and reverse temporal relaxations, and determining the calculation result as the actual interval value.

[0035] The process of comparing the actual interval value with the time overlap deviation range to identify connection paths where the interval value is less than zero and the absolute value exceeds the deviation range specifically involves: determining whether the actual interval value is less than zero; if the actual interval value is less than zero, performing an absolute value operation on the actual interval value to generate the absolute value of the conflict time; calling the allowed time overlap deviation range included in the node timing boundary parameters to construct an inequality comparison logic based on the allowed time overlap deviation range; if the absolute value of the conflict time is numerically greater than the allowed time overlap deviation range, determining that there is an irreconcilable timing conflict between the predecessor node and the successor node; extracting the directed edge connecting the predecessor node and the successor node, modifying the attribute identifier of the directed edge to a process mutual exclusion edge, and writing the absolute value of the conflict time as a mutual exclusion weight into the attribute list of the process mutual exclusion edge.

[0036] Compared with the prior art, the advantages and positive effects of the present invention are as follows:

[0037] In this invention, by extracting historical task interaction logs, constructing an attribute sequential reach matrix, and calculating the attribute temporal preservation degree vector, stable order characteristics of attribute pairs can be identified in multiple task flows. Parameter items with high temporal dependency value are selected for constructing task initiation rule templates. A multidimensional attribute mapping tensor model is established by vector encoding of column fields and their associated parameters. The flow connection type is determined by comparing the numerical density centroid offset with the node order difference. The flow path structure is generated in a directed graph manner, and the execution duration and task overlap tolerance period in the flow are extracted to identify mutually exclusive edges. The path execution logic is reconstructed based on the conflict area range. This effectively solves the problems of repetitive structure, scattered parameter configuration, and uncontrollable execution path conflicts in traditional task initiation flows, achieving efficient generation and reasonable configuration of task flows. Attached Figure Description

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

[0039] Figure 1 This is a schematic diagram of the steps of the present invention;

[0040] Figure 2 This is a detailed schematic diagram of S1 of the present invention;

[0041] Figure 3 This is a detailed schematic diagram of S2 of the present invention;

[0042] Figure 4 This is a detailed schematic diagram of S3 of the present invention;

[0043] Figure 5 This is a detailed schematic diagram of S4 of the present invention;

[0044] Figure 6 This is a detailed schematic diagram of S5 of the present invention. Detailed Implementation

[0045] The technical solution of the present invention will now be described with reference to the accompanying drawings.

[0046] In embodiments of the present invention, words such as "exemplarily," "for example," etc., are used to indicate that something is an example, illustration, or description. Any embodiment or design described as "exemplary" in the present invention should not be construed as being more preferred or advantageous than other embodiments or designs. Specifically, the use of the word "exemplary" is intended to present the concept in a concrete manner. Furthermore, in embodiments of the present invention, the meaning expressed by "and / or" can be both, or either one.

[0047] In the embodiments of this invention, the terms "image" and "picture" may sometimes be used interchangeably. It should be noted that, without emphasizing the distinction between them, they convey the same meaning. Similarly, the terms "of," "corresponding (relevant)," and "corresponding" may sometimes be used interchangeably. It should be noted that, without emphasizing the distinction between them, they convey the same meaning.

[0048] In this embodiment of the invention, sometimes a subscript such as W1 may be written in a non-subscript form such as W1. When the difference is not emphasized, the meaning they express is the same.

[0049] To make the technical problems, technical solutions and advantages of the present invention clearer, a detailed description will be given below in conjunction with the accompanying drawings and specific embodiments.

[0050] Please see Figure 1 This invention provides a custom-based task initiation method, including the following steps:

[0051] S1: Collect historical task interaction logs, extract task attribute timestamp sequences and task node identifiers from the historical task interaction logs, and bind the task attribute timestamp sequences and task node identifiers to construct an attribute sequential reach matrix in which rows correspond to a single task process and columns correspond to a set of task attributes.

[0052] S2: Calculate the average order of occurrence of attribute pairs in the attribute access matrix, statistically analyze the frequency of attribute pairs maintaining a stable temporal relationship in a multi-task process to generate a temporal preservation vector, and filter the priority of initiation conditions based on the temporal preservation vector and combine them to generate a task initiation rule template.

[0053] S3: Based on the task initiation rule template, initiate a new project definition instruction and establish a start column, initiator column, approval column and end column to form a basic column framework. Perform vector encoding processing on the item type number, initiator role level value, approval node numerical order and expected processing cycle associated with the basic column framework to generate a fixed-length vector structure, and construct a four-dimensional attribute mapping tensor information that represents the attribute mapping relationship within the basic column framework.

[0054] S4: Slice the four-dimensional attribute mapping tensor information to obtain two-dimensional attribute column slices, perform numerical density centroid offset operation on the two-dimensional attribute column slices to obtain the centroid offset direction, compare the centroid offset direction with the node order difference to determine the process connection type, and generate a task flow directed graph based on the process connection type.

[0055] S5: Extract the expected execution time and the maximum task overlap tolerance period from the directed graph of the task flow as node timing boundary parameters. Based on the node timing boundary parameters, perform bidirectional timing value difference judgment on the node edge pairs in the directed graph of the task flow to identify process mutual exclusion edges. Aggregate the conflict area range according to the process mutual exclusion edges and perform logical equivalent reconstruction of the path to generate custom task flow information.

[0056] The attribute priority reach matrix consists of task instance index rows, attribute category mapping columns, and reach timing numerical elements. The task initiation rule template consists of attribute triggering logic items, condition combination priority, and timing dependency constraint bits. The four-dimensional attribute mapping tensor information consists of column feature vector layer, attribute coupling coefficient layer, and spatial mapping index layer. The task flow directed graph consists of node connection topology, flow control weights, and path state transition points. The custom task flow information consists of logically equivalent path segments, timing conflict avoidance strategies, and node execution configuration tables.

[0057] Please see Figure 2 The specific steps of S1 are as follows:

[0058] S101: Collect historical task interaction logs, perform regular expression matching and field segmentation on unstructured log data streams, remove invalid record items that are missing task numbers or operation instructions, extract a set of fields including the unique task identifier, operation type code and operation occurrence time, perform standardized format conversion on the operation time field to convert it into a long integer numerical format, and generate a structured task interaction record set.

[0059] This embodiment is applied to the business process automation construction scenario of a large enterprise resource planning system. A log collection probe deployed on the business system server cluster accesses the read-only interface of the backend database in real time, collecting historical task interaction logs at a rate of 5,000 logs per second. For the collected unstructured log data stream containing a large number of redundant characters, newlines, and garbled characters, a pre-built regular expression engine is invoked to perform strict character matching and field segmentation operations. Specifically, the regular expression matching logic is set to identify text lines starting with a standard date format and locate the key-value pair structure within square brackets. For example, for a raw log entry "ERROR 2025-03-15 08:30:00 [TaskID: PROJ-Alpha-001][User: Admin] [OP: INIT_SUBMIT] Connection Timeout", validity is verified by matching the existence of the keywords "TaskID" and "OP". Since this record contains a clear task number and operation instructions, it is determined to be a valid record. Subsequently, "PROJ-Alpha-001" was extracted as the unique task identifier, "INIT_SUBMIT" was extracted as the operation type code, and "2025-03-15 08:30:00" was extracted as the operation occurrence time. For the extracted operation time field, a normalized format conversion operation was performed, converting the date string into a long integer Unix timestamp value accurate to milliseconds, i.e., "1773563400000", according to the Coordinated Universal Time standard. This generated a structured task interaction record set composed of structured fields, as shown in Table 1.

[0060] Table 1. Example of a structured task interaction record set

[0061]

[0062] S102: Call the structured task interaction record set, group and aggregate the record items according to the unique task identifier, extract the operation type code from each group of records as the task node identifier, extract the corresponding standardized time value synchronously, form a task attribute timestamp sequence, establish a corresponding index mapping relationship between the task node identifier and the task attribute timestamp sequence under the same task, and generate a time sequence node feature mapping table.

[0063] Records are grouped and aggregated using the unique task identifier (e.g., "PROJ-Alpha-001") as the primary key, merging all interaction records belonging to the same task into the same data block. For each aggregated group, the operation type code (e.g., "INIT_SUBMIT", "DEPT_AUDIT") is extracted as the task node identifier in the task flow, and the corresponding standardized time values ​​(e.g., "1773563400000", "1773564000000") are extracted simultaneously and arranged sequentially to form a task attribute timestamp sequence. Subsequently, a hash index structure is built in the in-memory database, using the unique task identifier as the key and the combination of the task node identifier list and the task attribute timestamp sequence as the value, establishing a one-to-one index mapping relationship to generate a time-series node feature mapping table containing the complete historical process trajectory.

[0064] S103: Based on the time sequence node feature mapping table, extract all unique task identifiers that are not repeated, define the matrix row dimension, identify independent task node identifiers, define the matrix column dimension, traverse the index mapping relationship corresponding to the task, obtain the timestamp value of the node attribute being referenced for the first time in the process, fill the timestamp value into the row and column intersection cell and pad zeros for unreached positions, and construct the attribute sequential reach matrix.

[0065] Extract all unique task identifiers (N in total) to define the row-level index of the matrix, identify all occurrences of independent task node identifiers (M in total) to define the column-level index of the matrix, and initialize an N-row, M-column sparse matrix structure. Traverse the index mapping relationship corresponding to each task, retrieve the position of the first occurrence of a specific task node identifier in the current task attribute timestamp sequence, and obtain the standardized timestamp value corresponding to that position. For example, when processing the "PROJ-Alpha-001" task row, if the timestamp value of the first reference in the process for the node attribute corresponding to the "DEPT_AUDIT" column is found to be "1773564000000", this long integer value is directly filled into the cell at the intersection of the row and column in the matrix. For nodes not involved in the task process (such as "HR_REVIEW"), zero values ​​are filled into the corresponding cells. Finally, construct an attribute arrival matrix where rows correspond to single task processes and columns correspond to task attribute sets, providing a standardized numerical foundation for subsequent time-series dependency analysis.

[0066] Please see Figure 3 The specific steps of S2 are as follows:

[0067] S201: Call the attribute sequential access matrix, traverse the matrix column vectors, extract the data rows with non-zero attribute timestamps, perform pairwise time series comparisons on any two attribute columns, count the number of samples where the timestamp value of the preceding attribute is less than the timestamp value of the following attribute, calculate the ratio of the number to the total number of present samples, determine the directional dependency probability, and construct an attribute time series correlation map representing the unidirectional flow intensity between attributes.

[0068] A non-zero value filtering algorithm is used to extract data rows with non-zero attribute timestamps, retaining only task samples that actually performed the corresponding operation. Pairwise time-series comparisons are performed on any two attribute columns (e.g., "INIT_SUBMIT" and "DEPT_AUDIT"). The number of samples where the timestamp of the preceding attribute (INIT_SUBMIT) is less than the timestamp of the succeeding attribute (DEPT_AUDIT) is counted among all co-occurring task samples. If 980 out of 1000 co-occurring samples satisfy the condition that "INIT_SUBMIT" is earlier than "DEPT_AUDIT", then 980 are considered the number of samples meeting the time-series constraint, and 1000 are considered the total number of co-occurring samples. The ratio of the number of samples meeting the time-series constraint to the total number of co-occurring samples, which is 0.98, is determined as the directional dependency probability. Based on the calculation results for all attribute pairs, a directed weighted graph structure is constructed, where nodes represent attributes and edge weights represent directional dependency probabilities, thus constructing an attribute time-series correlation graph representing the intensity of unidirectional flow between attributes.

[0069] S202: Based on the attribute temporal correlation graph, extract strong correlation edges whose directional dependency probability exceeds the preset stability benchmark value. For each attribute node, calculate its out-degree stability weight as the starting point of the temporal sequence and its in-degree stability weight as the ending point. Perform a weighted summation operation on the out-degree stability weight and the in-degree stability weight to quantify the temporal anchor point features of the attribute and generate a temporal preservation vector.

[0070] Extract the directional dependency probability values ​​between all attribute pairs in the attribute temporal correlation graph and construct a probability value set. This set is set to include values ​​such as {0.98, 0.95, 0.45, 0.50, ...}, and the arithmetic mean (set to 0.65) and standard deviation (set to 0.20) of this probability value set are calculated. A preset multiple of 1.5 is set, and the arithmetic mean and the standard deviation of the preset multiple are linearly weighted and summed, i.e., 0.65 plus the product of 1.5 and 0.20, resulting in 0.95, which is the stability benchmark value. Subsequently, strongly correlated edges whose directional dependency probabilities exceed this stability benchmark value (0.95) are extracted. For each attribute node, its out-degree stability weight (i.e., the weighted sum of the number and weights of high-probability edges pointing from this node to other nodes) as the temporal starting point and its in-degree stability weight as the ending point are calculated. A weighted summation operation is performed on the out-degree stability weights and in-degree stability weights (e.g., each weighted at 0.5) to quantify the anchor point features of the attribute in the time-series flow, generating a time-preservation vector. The advantage of this operation logic is that by adaptively defining a strong correlation threshold by combining statistical distribution characteristics, it effectively eliminates occasional or unstable process jump paths, ensuring the robustness of core backbone process identification.

[0071] S203: Based on the time-preservation degree vector, sort the time-series anchor point feature values ​​of the attribute nodes in descending order, select the attribute with the feature value at the top preset quantile as the initiation condition priority, analyze the strong correlation edges between the initiation condition priority, establish a logical triggering link, convert the logical triggering link into a standardized structure including condition judges and logical connectors, and generate a task initiation rule template.

[0072] Attributes whose feature values ​​fall within the top preset quantile (e.g., the top 20%) are selected as initiation condition priorities. These attributes typically correspond to key milestone nodes in the process (such as "project application" and "preliminary financial review"). Then, the strong correlation edges between these initiation condition priorities are analyzed, and logical triggering links are established based on the probability of directional dependencies. For example, if the probability of "project application" pointing to "preliminary financial review" is 0.98, then a logical chain of "if the project application is completed, then the preliminary financial review will be triggered" is established. Finally, a pre-built rule interpreter is invoked to convert these logical triggering links into a standardized structure including conditional statements (IF, THEN) and logical connectors (AND, OR), generating a task initiation rule template that can be directly parsed by the workflow engine.

[0073] Please see Figure 4 The specific steps of S3 are as follows:

[0074] S301: Activate the project initialization interface based on the trigger logic item in the task initiation rule template, instantiate four independent functional entity objects: start node, initiator node, approval node and end node, assign a unique memory address identifier and status register bit to each functional entity object, configure data transmission links and control signal interfaces between each functional entity object according to logical connectors, and combine them to form the basic column topology architecture that carries the task flow logic.

[0075] The workflow definition unit activates the project initialization interface based on the trigger logic item in the task initiation rule template. It instantiates four independent functional entity objects—start node, initiator node, approval node, and end node—in the memory stack, assigning each functional entity object a unique 32-bit memory address identifier and an 8-bit status register bit for subsequent status tracking. Based on the logical connectors in the template, the system configures data transmission links and control signal interfaces based on the TCP / IP protocol between each functional entity object, combining them to form the basic column topology architecture that carries the task flow logic.

[0076] S302: Call the basic column topology architecture, traverse each functional entity object, extract the item type number, initiator role level value, approval node numerical order and expected processing cycle parameters, call the preset character index dictionary to map text parameters to discrete numerical indexes, perform linear scaling calculation on numerical parameters, map them to unit intervals, arrange the processed values ​​in a fixed order and fill them into an array container of preset dimensions, and generate a column attribute feature vector set;

[0077] The process of performing linear scaling calculations on numerical parameters and mapping them to unit intervals is as follows: First, obtain the numerical parameters, including the initiator's role level value and the numerical order of approval nodes. Then, iterate through the numerical parameters, identify the maximum and minimum boundary values ​​of the parameters within the global range, and calculate the difference between the numerical parameter and the minimum boundary value as the offset. Next, calculate the difference between the maximum and minimum boundary values ​​as the global range span, divide the offset by the global range span to obtain the normalization ratio, and use the normalization ratio as the mapped unit interval value.

[0078] The process of arranging the processed values ​​in a fixed order and filling them into an array container of a preset dimension is as follows: Construct a one-dimensional floating-point array container with a length equal to the number of basic column attributes; fill the corresponding index positions of the one-dimensional floating-point array container with discrete numerical indices and unit interval values ​​in sequence according to the item type number, initiator role level value, approval node numerical order and the predefined index order of the expected processing cycle; fill the empty positions in the one-dimensional floating-point array container with zero-value placeholders; perform L2 norm normalization on the filled one-dimensional floating-point array container to constrain the vector magnitude; and store the normalized one-dimensional floating-point array container as the attribute feature vector of a single column in the column attribute feature vector set.

[0079] Iterate through each functional entity object and extract parameters such as the item type number (e.g., Type_05), the initiator role level value (e.g., Level_3), the approval node numerical order (e.g., Order_2), and the expected processing cycle (e.g., 48 hours). Call the pre-set character index dictionary to map text parameters such as "Type_05" to discrete numerical indices (e.g., 105). For numerical parameters, perform linear scaling calculation. The specific process is as follows: Obtain numerical parameters including the initiator role level value (set to 3) and the approval node numerical order (set to 2). Iterate through the numerical parameters and identify the maximum boundary value (set to 10) and the minimum boundary value (set to 1) of the parameter in the global range. Calculate the difference (2) between the numerical parameter (3) and the minimum boundary value (1) as the offset; calculate the difference (9) between the maximum boundary value (10) and the minimum boundary value (1) as the global range span. Divide the offset (2) by the global span (9) to obtain the normalization ratio (approximately 0.222), and use this normalization ratio as the mapped unit interval value. Then, construct a one-dimensional floating-point array container with a length equal to the number of basic column attributes (set to 64 dimensions). According to the predefined index order of each parameter, sequentially fill the discrete numerical indices and unit interval values ​​into the corresponding index positions of the one-dimensional floating-point array container. Fill the empty positions in the one-dimensional floating-point array container with zero-value placeholders, and perform L2 norm normalization on the filled container to constrain the vector magnitude to 1, generating a column attribute feature vector set, as shown in Table 2.

[0080] Table 2 Example of Calculating Feature Vector Sets for Column Attributes

[0081]

[0082] S303: Obtain the set of feature vectors of column attributes, construct a four-dimensional coordinate space including column source dimension, column destination dimension, attribute feature dimension and time evolution dimension, map the feature vectors to the corresponding grid positions in the four-dimensional coordinate space according to the topological connection relationship between columns, perform dot product operation on any two column vectors in the attribute feature dimension, quantify the attribute coupling strength and fill it into the corresponding coordinate points, and generate four-dimensional attribute mapping tensor information;

[0083] A four-dimensional coordinate space is constructed, comprising the source dimension (Source_ID), target dimension (Target_ID), attribute feature dimension (Feature_Dim), and time evolution dimension (Time_Step). Feature vectors are mapped to corresponding grid positions in the four-dimensional coordinate space according to the topological connections between categories (e.g., the initiator node points to the approval node A). For any two category vectors (e.g., the initiator node vector and the approval node A vector), a dot product operation is performed on the attribute feature dimension, i.e., the sum of the products of the corresponding components of the two vectors is calculated. The result is used as a numerical value to quantify the attribute coupling strength and is filled into the corresponding coordinate points, generating a four-dimensional attribute mapping tensor.

[0084] Please see Figure 5 The specific steps of S4 are as follows:

[0085] S401: Call the four-dimensional attribute mapping tensor information, fix the attribute feature dimension and perform slice extraction along the time evolution axis to obtain two-dimensional attribute column slices, perform weighted moment operation on the coupling strength values ​​in the slice matrix, locate the density centroid coordinates, calculate the Euclidean distance and azimuth angle of the density centroid coordinates relative to the geometric center of the slice, construct vector parameters representing the flow trend and intensity between columns, and generate column coupling centroid offset vector.

[0086] A slice is essentially a thermodynamic matrix recording the coupling strength between nodes. For the coupling strength values ​​within the slice matrix, a weighted moment operation is performed: using grid coordinates as position variables and coupling strength as mass variables, the ratio of the first moment to the zeroth moment is calculated to locate the density barycenter coordinates. The Euclidean distance and azimuth angle of the density barycenter coordinates relative to the slice's geometric center (usually the matrix center point) are calculated to construct vector parameters characterizing the flow trend and intensity between sections, generating a section coupling barycenter offset vector.

[0087] S402: Obtain the column coupling center offset vector, extract the preset node order values ​​of the corresponding source column and destination column in the basic framework and calculate the algebraic difference, check the sign consistency between the projection component of the offset vector and the algebraic difference, if the signs are opposite, mark it as a reverse backtracking relationship, if the signs are the same, determine it as a direct serial or cross-stage parallel relationship based on the vector magnitude, and output the process connection type status information that characterizes the topological properties between nodes.

[0088] The process of verifying the sign consistency between the projected components of the offset vector and the algebraic difference is as follows: calculate the cosine similarity projection value of the column coupling center offset vector in the preset time evolution axis direction, and extract the sign value of the algebraic difference; perform the multiplication operation between the cosine similarity projection value and the algebraic difference. If the result is negative, it is determined that the center offset direction is contrary to the node temporal direction, and it is confirmed as a reverse backtracking relationship.

[0089] The process of determining whether a relationship is a direct serial or cross-stage parallel relationship based on the vector magnitude is as follows: the L2 norm of the column coupling center offset vector is calculated as the measured value of the magnitude, and the standard unit step size between adjacent nodes in the basic column framework is obtained; if the measured value of the magnitude is within the preset tolerance range of the standard unit step size, it is identified as a direct serial relationship; if the measured value of the magnitude exceeds the preset multiple threshold of the standard unit step size, it is identified as a cross-stage parallel relationship.

[0090] Extract the preset node order values ​​(e.g., source is 1, destination is 2) of the corresponding source and destination columns in the basic framework and calculate the algebraic difference (2-1=1). Perform sign consistency verification on the projection component of the offset vector and the algebraic difference. The specific process is as follows: calculate the cosine similarity projection value (set to 0.9) of the column coupling centroid offset vector in the preset time evolution axis direction. Extract the sign bit value of the algebraic difference (+1). Perform the multiplication operation of the cosine similarity projection value (0.9) and the algebraic difference (1). If the result is 0.9 (positive value), the direction is determined to be consistent. If the operation result is negative (e.g., the projection value is -0.5, and the algebraic difference is 1), it is determined that the centroid offset direction is contrary to the node temporal direction, and it is confirmed as a reverse backtracking relationship. Subsequently, determine the relationship type according to the vector magnitude: calculate the L2 norm of the column coupling centroid offset vector as the measured value of the magnitude (set to 1.05), and obtain the standard unit step size (set to 1.0) between adjacent nodes in the basic column framework. If the measured modulus length (1.05) is within the preset tolerance range of the standard unit step length (e.g., 0.8 to 1.2), it is identified as a direct serial relationship. If the measured modulus length exceeds the preset multiple threshold of the standard unit step length (e.g., greater than 2.0), it is identified as a cross-stage parallel relationship. The final output is the process connection type status information characterizing the topological properties between nodes.

[0091] S403: Based on the process connection type status information, initialize the adjacency matrix structure of the directed graph, insert non-zero weights at the corresponding node index positions, create directed edges, add synchronous convergence gateway nodes for parallel relationship types, add feedback edges with conditional constraints for reverse backoff relationships, traverse the matrix to perform reachability checks, eliminate broken paths and dead loop paths, and generate a directed graph of the task flow.

[0092] The process of adding a synchronous aggregation gateway node for parallel relationship types is as follows: In the initialization directed graph, a control class node without business attributes is instantiated as a synchronous aggregation gateway; a divergence path from the source column to the synchronous aggregation gateway and an aggregation path from the synchronous aggregation gateway to the destination column are established; a parallel branch identifier is configured on the divergence path and a waiting trigger condition is configured on the aggregation path to ensure that the multi-task flow completes state synchronization at the synchronous aggregation gateway before flowing to the destination column;

[0093] For node pairs identified as having a direct serial relationship, insert non-zero weights at the corresponding node index positions to create directed edges. For parallel relationship types, perform the operation of adding a synchronization convergence gateway node: instantiate a control class node without business attributes as the synchronization convergence gateway (Gateway_SYNC) in the initial directed graph, establish multiple divergent paths from the source section to the synchronization convergence gateway, and a convergence path from the synchronization convergence gateway to the destination section; configure parallel branch identifiers on the divergent paths, and configure waiting trigger conditions (such as "Wait All") on the convergence path to ensure that the multi-task flow completes state synchronization at the synchronization convergence gateway before flowing to the destination section. Traverse the matrix to perform reachability checks, eliminate broken paths and infinite loop paths, and generate a directed graph of the task flow.

[0094] Please see Figure 6 The specific steps of S5 are as follows:

[0095] S501: Call the directed graph of the task flow, traverse all task node entities in the graph structure, parse the internal attribute metadata, extract the preset standard task working hours and the maximum task overlap tolerance period, standardize the standard task working hours into the execution span of the time dimension, map the maximum task overlap tolerance period into the allowed time overlap deviation range, combine and bind the execution span and the time overlap deviation range into the timing configuration field of the corresponding node, and generate the node timing boundary parameters.

[0096] Traverse all task node entities in the graph structure (e.g., "Coding Development" and "Unit Testing"). Parse the internal attribute metadata to extract the preset standard task hours (e.g., 8 hours for "Coding Development") and the maximum task overlap tolerance period (e.g., 1 hour). Standardize the task hours to an execution span (8.0) in the time dimension, and map the maximum task overlap tolerance period to an allowed time overlap deviation range (1.0). Combine and bind the execution span and time overlap deviation range and encapsulate them into the timing configuration field of the corresponding node to generate the node timing boundary parameters.

[0097] S502: Based on the node temporal boundary parameters, calculate the earliest start time difference and the latest end time difference of adjacent node pairs in the directed graph, perform bidirectional temporal offset calculation on the connection edges between nodes to obtain the actual interval value, compare the actual interval value with the time overlap deviation range, identify connection paths with an interval value less than zero and an absolute value exceeding the deviation range, mark the path as a logical connection relationship with non-parallel attributes and exclusive constraints, and generate process mutual exclusion edges;

[0098] The process of performing bidirectional temporal offset calculations on the connecting edges between nodes to obtain the actual interval value is as follows: Based on the pointing relationships of the connecting edges in the directed graph of the task flow, determine the predecessor and successor nodes; extract the execution span from the node temporal boundary parameters corresponding to the predecessor node; add the earliest start time of the predecessor node to the execution span to obtain the earliest end time of the predecessor node; calculate the difference between the earliest start time of the successor node and the earliest end time of the predecessor node to obtain the forward temporal slack; calculate the difference between the latest start time of the successor node and the latest end time of the predecessor node to obtain the reverse temporal slack; perform a minimization filtering operation on the forward and reverse temporal slack, and determine the result as the actual interval value.

[0099] The process of comparing the actual interval value with the time overlap deviation range to identify connection paths where the interval value is less than zero and the absolute value exceeds the deviation range is as follows: First, determine if the actual interval value is less than zero. If the actual interval value is less than zero, perform an absolute value operation on the actual interval value to generate the absolute value of the conflict time. Then, call the allowed time overlap deviation range included in the node's timing boundary parameters to construct an inequality comparison logic based on the allowed time overlap deviation range. If the absolute value of the conflict time is numerically greater than the allowed time overlap deviation range, it is determined that there is an irreconcilable timing conflict between the preceding and succeeding nodes. Next, extract the directed edges connecting the preceding and succeeding nodes, modify the attribute identifier of the directed edges to process mutual exclusion edges, and write the absolute value of the conflict time as a mutual exclusion weight into the attribute list of the process mutual exclusion edges.

[0100] Based on the directed graph connections, the predecessor node (code development) and successor node (unit testing) are determined. The execution span of the predecessor node is extracted (8.0). The earliest start time of the predecessor node is set to T=0, then the earliest end time of the predecessor node is 0+8.0=8.0. The earliest start time of the successor node is set to T=7.5 (i.e., attempting to start earlier). The difference between the earliest start time of the successor node (7.5) and the earliest end time of the predecessor node (8.0) is calculated, resulting in a forward timing slack of -0.5. Similarly, the reverse timing slack is calculated. A minimum filtering operation is performed on both, and the result (-0.5) is determined as the actual interval value. Subsequently, the actual interval value is numerically compared with the time overlap deviation range. If the actual interval value (-0.5) is less than zero, an absolute value operation is performed on the actual interval value to generate the absolute value of the conflict time (0.5). The allowed time overlap deviation range (1.0) is called to construct the inequality comparison logic. Since the absolute value of the conflict time (0.5) is numerically no greater than the allowable time overlap deviation range (1.0), the conflict is deemed tolerable. If the actual interval value is -2.0, then the absolute value of the conflict time (2.0) is greater than the deviation range (1.0), and an irreconcilable temporal conflict is determined to exist between the predecessor node and the successor node. In this case, the directed edge connecting the predecessor node and the successor node is extracted, the attribute identifier of the directed edge is modified to a process mutual exclusion edge, and the absolute value of the conflict time (2.0) is written as the mutual exclusion weight into the attribute list of the process mutual exclusion edge, as shown in Table 3.

[0101] Table 3. Process Mutual Exclusion Edge Identification and Parameter Calculation Table

[0102]

[0103] S503: Based on the process of mutually exclusive edges, retrieve the set of all connection paths marked as exclusive in the directed graph, use the breadth-first search algorithm to delineate the local topology subgraph including mutually exclusive paths and their directly related nodes, aggregate the conflict area range, insert mutually exclusive logical gateway entities in the conflict area and replan the conditional branch routes to replace the original mutually exclusive connections, perform logical completeness verification on the reconstructed full graph paths and perform serialization encoding output, and generate a custom task flow definition;

[0104] A breadth-first search algorithm is used to define a local topology subgraph, including mutually exclusive paths and their directly associated nodes, aggregating conflict areas. Within each conflict area, a mutually exclusive logical gateway entity (Gateway_XOR) is inserted, and conditional branch routes are replanned to replace the original mutually exclusive connections. Logical completeness checks are performed on the reconstructed full-graph paths, and serialization encoding is performed to output a custom task flow definition. Compared to traditional manual definition methods, the flow definition generated through the above-mentioned temporal conflict detection and reconstruction mechanism reduces the resource deadlock rate by approximately 45% in actual operation, effectively improving the logical rigor and execution efficiency of the flow definition.

[0105] The above description is merely a specific embodiment of the present invention, but the scope of protection of the present invention is not limited thereto. Any variations or substitutions that can be easily conceived by those skilled in the art within the technical scope disclosed in the present invention should be included within the scope of protection of the present invention. Therefore, the scope of protection of the present invention should be determined by the scope of protection of the described technical solutions.

Claims

1. A custom task initiation method, characterized in that, Includes the following steps: S1: Collect historical task interaction logs, extract and bind attribute timestamp sequences and node identifiers, and construct an attribute sequential reach matrix; S2: Calculate the average order of the attribute arrival matrix, count the time series stability frequency, generate the time series preservation degree vector, filter and combine the initiation condition priority items, and generate a task initiation rule template. S3: Based on the task initiation rule template, initiate project definition, establish a basic column framework with start, initiator, approval, and end columns, encode the item type number, initiator role level value, approval node sequence and expected processing cycle to generate a fixed-length vector structure, and construct four-dimensional attribute mapping tensor information. S4: Slice the four-dimensional attribute mapping tensor information to obtain two-dimensional attribute column slices, calculate the centroid offset direction, compare the difference between the centroid offset direction and the node order to determine the process connection type, and construct a directed graph of the task process. S5: Extract the expected duration and maximum task overlap tolerance period from the directed graph of the task flow as node time sequence boundary parameters, perform bidirectional time sequence value difference judgment on the node edge pairs in the directed graph of the task flow to identify process mutual exclusion edges, aggregate conflict areas, reconstruct paths to generate custom task flow information.

2. The custom-based task initiation method according to claim 1, characterized in that, The attribute sequential reach matrix specifically comprises task instance index rows, attribute category mapping columns, and reach timing numerical elements. The task initiation rule template specifically comprises attribute triggering logic items, condition combination priority, and timing dependency constraint bits. The four-dimensional attribute mapping tensor information specifically comprises a column feature vector layer, an attribute coupling coefficient layer, and a spatial mapping index layer. The task flow directed graph specifically comprises node connection topology, flow control weights, and path state transition points. The custom task flow information specifically comprises logically equivalent path segments, timing conflict avoidance strategies, and node execution configuration tables.

3. The custom-based task initiation method according to claim 1, characterized in that, The specific steps of S1 are as follows: S101: Collect historical task interaction logs, perform regular expression matching and field segmentation on unstructured log data streams, remove invalid record items that are missing task numbers or operation instructions, extract a set of fields including the unique task identifier, operation type code and operation occurrence time, perform standardized format conversion on the operation time field to convert it into a long integer numerical format, and generate a structured task interaction record set. S102: Call the structured task interaction record set, group and aggregate the record items according to the unique task identifier, extract the operation type code from each group of records as the task node identifier, synchronously extract the corresponding standardized time value, form a task attribute timestamp sequence, establish a corresponding index mapping relationship between the task node identifier and the task attribute timestamp sequence under the same task, and generate a time sequence node feature mapping table. S103: Based on the time-series node feature mapping table, extract all unique task identifiers that are not repeated, define the matrix row dimension, identify independent task node identifiers, define the matrix column dimension, traverse the index mapping relationship corresponding to the task, obtain the timestamp value of the node attribute being referenced for the first time in the process, fill the timestamp value into the row and column intersection cells and pad zeros for unreached positions, and construct the attribute sequential reach matrix.

4. The custom-based task initiation method according to claim 1, characterized in that, The specific steps of S2 are as follows: S201: Call the attribute sequential access matrix, traverse the matrix column vectors, extract the data rows with non-zero attribute timestamps, perform pairwise time series comparisons on any two attribute columns, count the number of samples where the timestamp value of the preceding attribute is less than the timestamp value of the following attribute, calculate the ratio of the number to the total number of present samples, determine the directional dependency probability, and construct the attribute time series association graph. S202: Based on the attribute temporal correlation graph, extract strong correlation edges whose directional dependency probability exceeds the preset stability benchmark value. For each attribute node, calculate its out-degree stability weight as the starting point of the temporal sequence and its in-degree stability weight as the ending point. Perform a weighted summation operation on the out-degree stability weight and the in-degree stability weight to quantify the temporal anchor point features of the attribute and generate a temporal preservation vector. S203: Based on the time-preservation vector, sort the time-anchor feature values ​​of the attribute nodes in descending order, select the attribute whose feature value is located at the top preset quantile as the initiation condition priority, analyze the strong correlation edges between the initiation condition priority, establish a logical triggering link, convert the logical triggering link into a standardized structure including condition judges and logical connectors, and generate a task initiation rule template.

5. The custom-based task initiation method according to claim 4, characterized in that, The method for setting the stability benchmark value is as follows: extract the directional dependency probability between all attribute pairs in the attribute time-series correlation graph, construct a set of probability values, calculate the arithmetic mean and standard deviation of the set of probability values, and perform a linear weighted summation operation on the arithmetic mean and the standard deviation by a preset multiple to obtain the stability benchmark value.

6. The custom-based task initiation method according to claim 1, characterized in that, The specific steps for S3 are as follows: S301: Activate the project initialization interface based on the trigger logic item in the task initiation rule template, instantiate four independent functional entity objects: start node, initiator node, approval node and end node, assign a unique memory address identifier and status register bit to each functional entity object, configure data transmission link and control signal interface between each functional entity object according to logical connector, and combine them to form the basic column topology architecture that carries the task flow logic. S302: Call the basic column topology architecture, traverse each functional entity object, extract the item type number, initiator role level value, approval node numerical order and expected processing cycle parameter, call the preset character index dictionary to map the text parameters to discrete numerical index, perform linear scaling calculation on the numerical parameters, map them to unit interval, arrange the processed values ​​in a fixed order and fill them into an array container of preset dimensions, and generate a column attribute feature vector set; S303: Obtain the set of feature vectors of the column attributes, construct a four-dimensional coordinate space including column source dimension, column destination dimension, attribute feature dimension and time evolution dimension, map the feature vectors to the corresponding grid positions in the four-dimensional coordinate space according to the topological connection relationship between columns, perform dot product operation on any two column vectors in the attribute feature dimension, quantify the attribute coupling strength and fill it into the corresponding coordinate point, and generate four-dimensional attribute mapping tensor information.

7. The custom-based task initiation method according to claim 1, characterized in that, The specific steps of S4 are as follows: S401: Call the four-dimensional attribute mapping tensor information, fix the attribute feature dimension and perform slice extraction along the time evolution axis to obtain two-dimensional attribute column slices, perform weighted moment operation on the coupling strength value in the slice matrix, locate the density centroid coordinates, calculate the Euclidean distance and azimuth angle of the density centroid coordinates relative to the geometric center of the slice, construct vector parameters representing the flow trend and intensity between columns, and generate column coupling centroid offset vector; S402: Obtain the column coupling center offset vector, extract the preset node order value of the corresponding source column and destination column in the basic framework and calculate the algebraic difference, check the sign consistency between the projection component of the offset vector and the algebraic difference, if the signs are opposite, mark it as a reverse backtracking relationship, if the signs are the same, determine it as a direct serial or cross-stage parallel relationship based on the vector magnitude, and output the process connection type status information. S403: Based on the process connection type status information, initialize the adjacency matrix structure of the directed graph, insert non-zero weights at the corresponding node index positions, create directed edges, add synchronous convergence gateway nodes for parallel relationship types, add feedback edges with conditional constraints for reverse backoff relationships, traverse the matrix to perform reachability detection, eliminate broken paths and dead loop paths, and generate a directed graph of the task flow.

8. The custom-based task initiation method according to claim 7, characterized in that, The process of verifying the sign consistency of the projection components of the offset vector and the algebraic difference specifically involves calculating the cosine similarity projection value of the column coupling center offset vector in the preset time evolution axis direction and extracting the sign value of the algebraic difference; performing a multiplication operation between the cosine similarity projection value and the algebraic difference; if the result is negative, it is determined that the center offset direction is contrary to the node temporal direction, and it is confirmed as a reverse backtracking relationship. The process of determining whether a relationship is a direct serial or cross-stage parallel relationship based on the vector magnitude is as follows: the L2 norm of the column coupling centroid offset vector is calculated as the measured value of the magnitude, and the standard unit step size between adjacent nodes in the basic column framework is obtained; if the measured value of the magnitude is within the preset tolerance range of the standard unit step size, it is identified as a direct serial relationship; if the measured value of the magnitude exceeds the preset multiple threshold of the standard unit step size, it is identified as a cross-stage parallel relationship.

9. The custom-based task initiation method according to claim 1, characterized in that, The specific steps of S5 are as follows: S501: Call the directed graph of the task flow, traverse all task node entities in the graph structure, parse the internal attribute metadata, extract the preset standard task working hours and the maximum task overlap tolerance period, standardize the standard task working hours into the execution span of the time dimension, map the maximum task overlap tolerance period into the allowed time overlap deviation range, combine and bind the execution span and the time overlap deviation range and encapsulate them into the timing configuration field of the corresponding node to generate the node timing boundary parameters; S502: Based on the node timing boundary parameters, calculate the earliest start time difference and the latest end time difference of adjacent node pairs in the directed graph, perform bidirectional timing offset calculation on the connection edges between nodes, obtain the actual interval value, compare the actual interval value with the time overlap deviation range, identify connection paths with an interval value less than zero and an absolute value exceeding the deviation range, mark the path as a logical connection relationship with non-parallel attributes and exclusive constraints, and generate process mutual exclusion edges; S503: Based on the process of retrieving all mutually exclusive connection paths marked as exclusive in the directed graph, the local topology subgraph including mutually exclusive paths and their directly associated nodes is delineated by breadth-first search algorithm, the conflict area range is aggregated, mutually exclusive logical gateway entities are inserted in the conflict area and conditional branch routes are replanned to replace the original mutually exclusive connections, the logical completeness of the reconstructed full graph paths is checked and serialized and encoded for output, and a custom task flow definition is generated.

10. The custom-based task initiation method according to claim 9, characterized in that, The process of performing bidirectional temporal offset calculations on the connecting edges between nodes to obtain the actual interval value specifically involves: determining the predecessor and successor nodes based on the pointing relationships of the connecting edges in the directed graph of the task flow; extracting the execution span from the node temporal boundary parameters corresponding to the predecessor node; adding the earliest start time of the predecessor node to the execution span to obtain the earliest end time of the predecessor node; calculating the difference between the earliest start time of the successor node and the earliest end time of the predecessor node to obtain the forward temporal relaxation; calculating the difference between the latest start time of the successor node and the latest end time of the predecessor node to obtain the reverse temporal relaxation; performing a minimization filtering operation on the forward and reverse temporal relaxations, and determining the result as the actual interval value. The process of comparing the actual interval value with the time overlap deviation range to identify connection paths where the interval value is less than zero and the absolute value exceeds the deviation range specifically involves: determining whether the actual interval value is less than zero; if the actual interval value is less than zero, performing an absolute value operation on the actual interval value to generate the absolute value of the conflict time; calling the allowed time overlap deviation range included in the node timing boundary parameters to construct an inequality comparison logic based on the allowed time overlap deviation range; if the absolute value of the conflict time is numerically greater than the allowed time overlap deviation range, determining that there is an irreconcilable timing conflict between the predecessor node and the successor node; extracting the directed edge connecting the predecessor node and the successor node, modifying the attribute identifier of the directed edge to a process mutual exclusion edge, and writing the absolute value of the conflict time as a mutual exclusion weight into the attribute list of the process mutual exclusion edge.

Images