An intelligent optimization scheduling and management method and system for a project whole process

Abstract

The application discloses a kind of intelligent optimization scheduling and management method and system for project whole process, it is related to project scheduling and management technical field.The method includes: acquisition task, resource, dependent and constraint data constructs knowledge graph;Parameter is extracted based on atlas and establishes multi-objective optimization model;Pareto solution set is obtained by using double colony collaborative evolution non-dominated sorting genetic algorithm;Select scheme execution and collect event log;Actual execution model is found by Petri net process mining, deviation and bottleneck are identified and adjustment instruction is generated to update atlas, form closed loop iteration.The application deeply fuses knowledge graph, collaborative evolution and process mining, realizes project whole process adaptive optimization scheduling, and significantly improves robustness and execution efficiency.

Description

Technical Field

[0001] This invention relates to the field of project scheduling and management technology, and in particular to an intelligent optimization scheduling and management method and system for the entire project process. Background Technology

[0002] In large-scale engineering project management practice, end-to-end project management faces severe challenges from multi-dimensional complex constraints and dynamic uncertainties. A typical end-to-end project process includes the project initiation phase, planning and design phase, procurement phase, construction execution phase, monitoring and control phase, and closing and delivery phase. These phases are coupled through information flow, resource flow, and workflow, forming a complex process network with dependencies and feedback loops. Currently, most engineering project management still relies heavily on manual experience-based judgment and static plan execution. When faced with dynamic events such as frequent task delays, resource conflicts, and requirement changes during project execution, managers struggle to quickly generate globally optimal adjustment plans.

[0003] Existing technical literature shows that project scheduling under resource constraints has been extensively studied. Researchers have proposed various multi-objective optimization algorithms to solve optimization objectives such as minimizing project duration, minimizing cost, and maximizing resource utilization in project scheduling. For example, some studies have established multi-objective mathematical models incorporating task coding constraints, material availability constraints, and process constraints, with the optimization objectives of minimizing the total project duration and maximizing the coordination scheduling factor, and employ a non-dominated sorting genetic algorithm incorporating ecological community evolution mechanisms for solution. Another study proposed a dynamic resource scheduling method for EPC projects based on multi-objective optimization. This method extracts the project start time and activity attributes from the EPC project, constructs a project activity list and a project resource list, establishes multi-objective functions and constraints, and uses multi-objective optimization algorithms to obtain the optimal resource scheduling scheme including project duration, cost, and resource utilization. Still other research has proposed an intelligent decision-making system for project management integrating multi-objective resource scheduling optimization. This system uses an equipment status sensing module to collect real-time operating parameters of key construction equipment, including real-time equipment location coordinates, actual speed, fault warning coefficient, actual working time, and actual completion time.

[0004] However, the aforementioned existing technologies have the following three shortcomings in practical applications:

[0005] First, existing technologies lack a systematic modeling and continuous updating mechanism for knowledge relationships throughout the entire project process. Experience data generated during project execution (such as actual task time, actual resource consumption, and actual buffer time between processes) is not effectively structured, stored, and reused, rendering historical experience unable to guide future scheduling decisions. Although some research has proposed using knowledge graphs to represent entities and their relationships to capture complex dependencies, this approach is only used for static resource allocation decisions and does not deeply integrate knowledge graphs with dynamic scheduling optimization throughout the entire process.

[0006] Second, existing multi-objective optimization scheduling methods mainly generate static scheduling schemes during the initial planning stage of a project, lacking a real-time response mechanism for dynamic disturbances during project execution. When task delays, resource unavailability, or requirement changes occur during project execution, existing methods typically require rerunning the entire optimization calculation process, resulting in long response delays and failing to meet the real-time adjustment requirements of engineering projects.

[0007] Third, existing technologies lack the ability to automatically extract process bottlenecks and anomaly patterns from project execution logs. Traditional process mining methods suffer from inefficiency and model explosion when processing event logs containing complex loops, parallelism, and selection structures, making it difficult to directly extract structured knowledge from raw execution logs that can guide scheduling optimization.

[0008] The shortcomings at these three levels are not isolated but interconnected: the lack of static knowledge modeling capabilities renders historical experience unsuitable for guiding current scheduling; the broken information loop in multi-objective optimization and execution processes prevents optimization results from adaptively adjusting as the project evolves; and insufficient execution process analysis capabilities hinder the automation of bottleneck identification. The combination of these problems makes it difficult for existing technologies to achieve closed-loop intelligent management of the entire project lifecycle—"planning-execution-monitoring-optimization"—severely limiting the potential for improving overall project performance.

[0009] Therefore, there is an urgent need for a method that can organically integrate knowledge graph-driven constraint modeling, multi-objective evolutionary algorithm-driven scheduling optimization, and Petri net process mining-driven execution analysis and adaptive adjustment to achieve intelligent optimization scheduling and management of the entire project process. Summary of the Invention

[0010] To achieve the above objectives, this invention provides an intelligent optimization scheduling and management method and system for the entire project process. The intelligent optimization scheduling and management method for the entire project process includes the following steps:

[0011] Step 1: Collect basic data for the entire project process and construct an initial knowledge graph of the entire project process. The basic data for the entire project process includes task data, resource data, dependency data, and constraint data. Map the task data to task entity nodes and the resource data to resource entity nodes. Establish directed dependency edges between the task entity nodes based on the dependency data. Establish assignable relationship edges between the task entity nodes and the resource entity nodes based on the skill types required by the tasks in the task data and the skill types to which the resources belong in the resource data.

[0012] Step 2: Based on the initial project full-process knowledge graph, extract the task set, resource set, dependency matrix, estimated task duration, resource availability time period set, skill requirement level and constraints, and construct a multi-objective optimization scheduling model that includes minimizing the total project duration optimization objective, minimizing the total project cost optimization objective, and maximizing the resource load balancing optimization objective;

[0013] Step 3: The multi-objective optimization scheduling model is solved by using a non-dominated sorting genetic algorithm based on the dual-community cooperative evolution mechanism. The population is divided into two sub-communities: an exploratory community and a development community. The exploratory community adopts the first genetic operation strategy, and the development community adopts the second genetic operation strategy. The two sub-communities evolve in parallel and achieve cooperative search through periodic gene exchange. After the iteration, the Pareto optimal scheduling scheme set is extracted.

[0014] Step 4: Select an implementation scheme from the Pareto optimal scheduling scheme set and issue it for execution. Simultaneously collect the project execution process event log. Each event record in the project execution process event log includes the event occurrence timestamp, the task identifier associated with the event, the event type, and the resource identifier associated with the event.

[0015] Step 5: Analyze the event logs of the project execution process based on Petri net process mining technology to discover the actual execution process model, identify execution deviations through compliance checks, identify process bottlenecks through performance analysis, generate adaptive scheduling adjustment instructions, and update the initial project full-process knowledge graph based on the actual execution process model, the execution deviations, the process bottlenecks, and the adaptive scheduling adjustment instructions. After the update, iteratively execute steps 2 to 5.

[0016] Preferably, the task data in step 1 includes a unique task identifier, task name, task stage, estimated task duration, required skill type, and required skill level; the resource data includes a unique resource identifier, resource name, resource type, available resource time period, required skill type, skill level, and unit time cost; the dependency data includes predecessor task identifiers and successor task identifiers, used to describe the completion-start relationship, start-start relationship, completion-completion relationship, and start-completion relationship between tasks; the constraint data includes the earliest start time constraint, the latest completion time constraint, the maximum available resource quantity constraint, and stage milestone node constraints.

[0017] When mapping each task to a task entity node in the initial project's full-process knowledge graph, the attributes of the task entity node include the task's unique identifier, the task name, the stage to which the task belongs, the estimated duration of the task, the skill type required by the task, and the skill level required by the task; when mapping each resource to a resource entity node in the initial project's full-process knowledge graph, the attributes of the resource entity node include the resource's unique identifier, the resource name, the resource type, the resource's available time period, the skill type to which the resource belongs, the resource's skill level, and the resource's unit time cost; based on the preceding task identifier and the subsequent task identifier in the dependency relationship data... A task identifier is used to establish directed dependency edges between preceding and subsequent task entity nodes. The attributes of the dependency edges include dependency types, which can be completion-start, start-start, completion-completion, or start-completion. Based on the skill type and skill level required by the task, assignable edges are established between the task entity node and resource entity nodes with matching skill types and skill levels not lower than the required skill level. Each constraint condition in the constraint data is represented as a constraint rule node, and the constraint rule node is connected to the corresponding task entity node or resource entity node by applying it to the relation edge.

[0018] Preferably, the construction process of the multi-objective optimization scheduling model in step 2 specifically includes:

[0019] Extract task sets from the initial project's full-process knowledge graph. Where n represents the total number of tasks; extract resource set Where m represents the total number of resources; extract the dependency matrix P, where Indicates task Must be in the task Complete before starting. Indicates task With the task There is no finish-start type dependency between them; extract each task. Estimated construction period and tasks Skill level requirements for each skill type k Extract each resource Set of available resource time periods and resources Skill level for each skill type k Extract the earliest start time constraint from the constraints. And the latest completion time constraint of the task ;

[0020] Construct decision variables , Indicates the task Allocate resources implement, Indicates not to carry out the task Allocate resources Execute; build each task start time variable ;

[0021] The primary optimization objective is to minimize the total project duration, denoted as: The second optimization objective is to minimize the total project cost, expressed as: ,in Representing resources The unit time cost; the third optimization objective is to maximize resource load balancing, expressed as... ,in This represents the variance of the utilization rate of each resource. This represents the average utilization rate of each resource. utilization rate Defined as , Indicates the total project duration;

[0022] The constraints for constructing the multi-objective optimization scheduling model include: dependency constraints, for all... The task to ,have Resource capacity constraints, at any given time Allocate resources The number of tasks does not exceed 1; resource availability time constraints apply to all... Task Resources must exist. A certain available time period , making and Skill matching constraints, for all The allocation relationship must satisfy... This holds true for all skill types k; time window constraint. and .

[0023] Preferably, the non-dominated sorting genetic algorithm based on the dual-community cooperative evolution mechanism described in step 3 adopts a task sequence-resource allocation dual-segment chromosome encoding scheme. Each chromosome consists of a first gene segment and a second gene segment. The first gene segment is a task priority sequence with a length equal to the total number of tasks n. Each gene position in the first gene segment stores a task identifier. The first gene segment represents the priority order of task scheduling. The second gene segment is a resource allocation sequence with a length equal to the total number of tasks n. The value of the i-th gene position in the second gene segment represents the resource identifier allocated to the i-th task.

[0024] After generating the initial population, the initial population is randomly and equally divided into exploratory communities. With development clusters The exploratory community employs a first genetic operation strategy, which includes: a selection operation using a crowding tournament selection, where k individuals are randomly selected from the exploratory community each time, and the individual with the largest crowding distance is selected to enter the mating pool; and a crossover operation using a two-point crossover strategy, with the crossover probability being the first crossover probability. The mutation operation employs a uniform mutation strategy, with the mutation probability being the first mutation probability. The first mutation probability The value is higher than the preset standard mutation probability threshold;

[0025] The developed community employs a second genetic operation strategy, which includes: a crowding tournament selection operation for the selection operation; and a simulated binary crossover operation with a crossover probability equal to the second crossover probability. The mutation operation employs a polynomial mutation strategy, with the mutation probability being the second mutation probability. The second mutation probability The value is lower than the first mutation probability. ;

[0026] During the evolution, every Gene exchange operations are performed between the exploration community and the development community. The gene exchange operation is as follows: the top M individuals with the highest non-dominance front level are selected from the exploration community and the development community respectively, the selected M individuals are added to another sub-community at the same time, and the same number of individuals with the lowest non-dominance front level are removed from the receiving sub-community. The value is dynamically adjusted through an adaptive strategy. When the intersection ratio of the non-dominant frontier between the exploratory community and the developing community exceeds a threshold... Time increases When the intersection ratio is lower than the threshold Time decrease ;

[0027] After the evolutionary operation is completed, the exploratory community and the development community are respectively subjected to non-dominated ordination, and individuals are divided into different non-dominated frontier levels. ,from Individuals are selected sequentially to enter the next generation of the population until the subpopulation size reaches its maximum. If a non-dominant frontier level is selected... If the number of passengers exceeds the limit, then calculate... The crowding distance of each individual is considered, and individuals with larger crowding distances are prioritized for retention;

[0028] Iterate until the preset maximum number of iterations is reached. Merge all individuals from the exploratory community and the developed community, and extract the non-dominant frontier level. All individuals constitute the Pareto optimal scheduling scheme set.

[0029] Preferably, the method for selecting an implementation scheme from the Pareto optimal scheduling scheme set in step 4 is as follows: using a multi-criteria decision-making method based on ideal point distance, the Euclidean distance from each scheme in the Pareto optimal scheduling scheme set to the three optimization objective ideal value vectors is calculated, and the scheme with the smallest Euclidean distance is selected as the final implementation scheme. The three optimization objective ideal value vectors are composed of the minimum value of the optimization objective of minimizing the total project duration, the minimum value of the optimization objective of minimizing the total project cost, and the maximum value of the optimization objective of maximizing resource load balance in the Pareto front.

[0030] The final implementation plan is then distributed to the project execution system, wherein a specific start time and allocated resources are specified for each task in the final implementation plan.

[0031] During project execution, event logs are collected in real time through a data acquisition interface. Each event record in the event log includes an event timestamp, the task identifier associated with the event, the event type, the resource identifier associated with the event, and additional event information. The event types include task start events, task completion events, task pause events, task resumption events, resource allocation events, resource release events, and task change events.

[0032] The collected project execution process event logs are stored in units of trajectories. Each trajectory corresponds to the execution process of a project instance. Each trajectory consists of a sequence of events arranged in ascending order of event timestamps. The trajectories are formally represented as follows: ,in Let represent the i-th event record, and q represent the total number of events in the trajectory.

[0033] Preferably, the process of analyzing the project execution process event log based on Petri net process mining technology in step 5 includes:

[0034] Extract the actual task execution data from the project execution process event log for each completed task. Calculate the actual duration of the task. The actual duration of the task Equal to the task The timestamp of the corresponding task completion event minus the task The timestamp of the corresponding task start event is used to record the task. The actual resource identifier allocated With the task The actual resources and man-hours consumed;

[0035] A Petri net-based process discovery algorithm is used to discover the actual execution process model from the trajectory set of the project execution process event log. The actual execution process model is represented in the form of a workflow net, which is formally defined as a quadruple. Where P represents the finite set of all libraries, and T represents the finite set of transitions. This represents the set of directed arcs connecting places and transitions. The initial identifier is indicated; the execution steps of the process discovery algorithm include: traversing each trajectory in the project execution process event log, counting the frequency of follow-up relationships between tasks, and constructing a task relationship matrix; identifying sequential, parallel, selection, and cyclic relationships between tasks based on the follow-up relationship frequency; constructing the place nodes and transition nodes of the workflow network based on the identified relationship types, and establishing corresponding flow relationships; performing structured verification on the constructed workflow network to ensure that the workflow network satisfies the reachability and boundedness of Petri nets.

[0036] Preferably, the compliance check process for identifying execution deviations in step 5 includes:

[0037] The actual execution process model discovered is aligned and compared with the expected process model constructed based on the dependency matrix. The compliance check includes task execution order deviation detection and task duration deviation detection.

[0038] The task execution order deviation detection is as follows: detect whether the task execution order in the event log trajectory of the project execution process violates the dependency constraints in the expected process model. For the detected deviation event, record the deviation type, the task identifier in which the deviation occurred, and the timestamp of the deviation occurrence. The deviation type includes task early execution deviation, task delayed completion deviation, task skipping deviation, and task repeated execution deviation.

[0039] The task schedule deviation detection is as follows: for each task Calculate the project schedule deviation rate ,in The actual duration of the task. For the estimated project duration collected in step 1, when the project duration deviation rate... The absolute value exceeds the preset threshold At that time, determine the task There is a significant deviation in the project schedule.

[0040] Preferably, the process of identifying bottlenecks in the performance analysis in step 5 includes:

[0041] Average waiting time for each transition calculation task in the actual execution process model Cumulative delay of the process path in which the task is located Intensity of competition with resources ;

[0042] The average waiting time of the task The calculation method is as follows: ,in This indicates the number of times task t is executed. This represents the actual start time of the k-th execution of task t. This represents the planned start time of the k-th execution of task t;

[0043] The cumulative delay The calculation method is as follows: ,in This represents the set of all tasks on the critical path from the start of the process to task t. This represents the delay of a single execution of task u;

[0044] The intensity of resource competition The calculation method is as follows: ;

[0045] Tasks that meet one of the following conditions are identified as process bottlenecks: the average waiting time of the task. Ranked first among all tasks The cumulative delay amount Ranked first among all tasks or the intensity of resource competition Exceeding the preset threshold , where K is a preset percentile threshold parameter.

[0046] Preferably, the process of generating adaptive scheduling adjustment instructions and updating the initial project full-process knowledge graph based on the analysis results in step 5 includes:

[0047] Based on the execution deviation and the process bottleneck, an adaptive scheduling adjustment instruction is generated. The generation rules include: when a task execution deviation is detected that causes a resource conflict, a task start time postponement instruction is generated. The task start time postponement instruction includes a target task identifier and a postponed start time, and the postponement amount is the minimum time interval required to resolve the conflict; when a task completion delay deviation is detected and the schedule deviation rate is... Exceeding the preset threshold When the delay of the delayed task occurs, a start time postponement instruction is generated for all subsequent tasks affected by the delayed task, with the postponement amount equal to the delay amount of the preceding task. Resource allocation instructions are also generated for unstarted tasks on the process path where the delayed task is located. When a bottleneck task is identified, a bottleneck resolution instruction is generated, which includes a resource allocation instruction to allocate parallel execution resources to the bottleneck task and a process reorganization instruction to optimize the preceding dependencies of the bottleneck task. When the resource contention intensity... Exceeding the preset threshold At that time, a resource conflict resolution instruction is generated to adjust the priority order of multiple tasks competing for the same resource;

[0048] The operation of updating the initial project's full-process knowledge graph includes: updating the actual task duration attribute of the task entity nodes in the knowledge graph to the actual task duration. Update the actual resource allocation attribute of the task to the actual resource identifier. Update the task duration deviation rate attribute to the duration deviation rate. Based on the discovered actual flow relationships between tasks in the actual execution process model, new actual flow relationship edges are added to the knowledge graph, connecting the task entity nodes that are sequentially executed in the actual execution order; identified process bottleneck tasks are marked as bottleneck task node types, and bottleneck type attributes and average waiting time attributes are added to the process bottleneck task entity nodes; the generated adaptive scheduling adjustment instructions are added to the knowledge graph as scheduling adjustment instruction entity nodes, and the scheduling adjustment instruction entity nodes are connected to the target task entity nodes through adjustment object relationship edges, and the scheduling adjustment instruction entity nodes are connected to the deviation event entity nodes or process bottleneck task entity nodes that trigger the adjustment through generation basis relationship edges; the version number of the knowledge graph is incremented to form a knowledge graph version record with a timestamp.

[0049] Accordingly, embodiments of the present invention also provide an intelligent optimization scheduling and management system for the entire project process, including a memory configured to store instructions, a processor configured to retrieve the instructions from the memory, and capable of implementing an intelligent optimization scheduling and management method for the entire project process as described in any embodiment of the present invention when executing the instructions.

[0050] The beneficial effects of this invention are:

[0051] 1. This invention constructs a knowledge graph of the entire project process, unifying task data, resource data, dependency data, and constraint data into a structured knowledge network. Based on a non-dominated sorting genetic algorithm with a dual-community collaborative evolution mechanism, it generates a set of Pareto optimal scheduling schemes. Furthermore, it integrates Petri net process mining technology to automatically identify deviations and bottlenecks from execution logs, generate adaptive adjustment instructions, and update the knowledge graph. This forms a closed-loop iterative system of "knowledge-driven modeling—multi-objective optimization scheduling—process mining analysis—adaptive adjustment and update," realizing dynamic collaborative optimization of the project planning and execution process, and significantly improving the robustness and execution efficiency of the scheduling scheme in the face of disturbances.

[0052] 2. This invention employs a dual-community collaborative evolution mechanism, dividing the population into an exploratory community and a development community for parallel search. The exploratory community maintains the diversity of the solution space by varying the asynchronous length over a large period, while the development community refines the local optimum by varying the asynchronous length over a small period. Furthermore, periodic gene exchange operations enable the two sub-communities to complement each other's strengths, ensuring the uniformity of Pareto front solutions while maintaining convergence speed. This solves the problem of traditional single-population evolutionary algorithms easily getting trapped in local optima.

[0053] 3. This invention utilizes Petri net process mining technology to automatically discover the actual execution process model from event logs. It identifies deviations in task execution order and schedule through compliance checks, calculates average waiting time, cumulative delay, and resource contention intensity based on performance analysis to locate process bottlenecks, and transforms deviation events and bottleneck tasks into scheduling adjustment instructions to update the knowledge graph. This enables the knowledge graph to have continuous self-learning capabilities, and the knowledge of the entire project process management is continuously accumulated and reused as the execution process progresses, realizing accurate guidance of historical experience for current scheduling decisions. Attached Figure Description

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

[0055] Figure 1 This is a flowchart of the steps of the method of the present invention. Detailed Implementation

[0056] The present invention will now be described in detail with reference to the accompanying drawings and specific embodiments. It should also be noted that, to make the embodiments more comprehensive, the following embodiments are the best and preferred embodiments, and those skilled in the art can use other alternative methods to implement some well-known technologies; moreover, the accompanying drawings are only for more specific description of the embodiments and are not intended to specifically limit the present invention.

[0057] Please see Figure 1This invention provides an intelligent optimization scheduling and management method and system for the entire project process. The application scenario of this embodiment is a large-scale bridge construction project. This project includes multiple construction stages such as main tower construction, bridge deck paving, cable-stayed cable installation, and ancillary facility installation. It involves various resource types, including pile foundation construction teams, steel structure installation teams, concrete pouring teams, surveying teams, and supervisors. Complex technological dependencies exist between the various construction tasks, and the project is subject to constraints such as weather windows, material arrival times, and equipment rental periods. The total planned project duration is 540 calendar days, with a total budget of approximately 280 million yuan. During project execution, frequent dynamic disturbances occurred, including construction delays due to weather, idle time due to delayed material arrivals, and resource conflicts due to critical equipment failures. Traditional static planning and scheduling methods struggle to quickly generate a global adjustment plan that balances schedule, cost, and resources after disturbances occur, resulting in the actual project duration being extended by 67 calendar days compared to the planned duration, and the actual cost exceeding the budget by approximately 22 million yuan. The method described in this embodiment enables intelligent optimization scheduling and management of the entire project process, achieving closed-loop linkage between planning and execution, and significantly improving the overall project performance.

[0058] Example

[0059] The intelligent optimization scheduling and management method for the entire project process in this embodiment includes the following five steps.

[0060] Step 1: Collect basic data for the entire project process and construct an initial knowledge graph of the entire project process;

[0061] First, collect basic data for the entire project process, specifically including four categories: task data, resource data, dependency data, and constraint data.

[0062] The task data collection covers all 187 construction tasks of the bridge construction project. Each task's data collection fields include: a unique task identifier, using the coding rule "T-stage code-three-digit serial number," for example, "T-FD-001" represents the first task in the foundation construction stage, "pile foundation positioning and setting out"; the task name, using standard construction terminology, such as "reinforcement binding of the third segment of the main tower"; the task's stage, divided into initiation, design, procurement, construction, monitoring, and completion stages; the estimated task duration, recorded in hours, such as "120h"; the required skill type, categorized by construction trade, including six types: "pile foundation construction," "steel structure installation," "concrete pouring," "surveying and setting out," "mechanical and electrical installation," and "welding operations"; and the required skill level, divided into five levels from level one to level five, with level one representing a junior worker and level five representing a senior technician.

[0063] The resource data collection covers all 63 resources available in the project. Each resource's data collection fields include: a unique resource identifier, using the encoding rule "R-type code-two-digit serial number," for example, "R-PL-03" represents the pile foundation construction team resource numbered 03; a resource name, for example, "Pile Foundation Construction Team No. 2"; a resource type, categorized into five types: "Construction Team," "Supervisor," "Lifting Equipment," "Concrete Pump Truck," and "Surveying Instruments"; a resource availability period, recorded as a list of date intervals, for example, "[2025-03-01, 2025-06-30]" indicates that the resource is available from March 1st to June 30th, 2025; the resource's skill type, using the same classification system as the skill type required for the task; the resource skill level, also using a five-level classification from level one to level five; and the resource's unit time cost, recorded in "yuan / hour," for example, "580 yuan / h" indicates that the scheduling cost of this resource is 580 yuan per hour.

[0064] The collection of dependency data covers the process sequence constraints between tasks. Each dependency record includes the following fields: a predecessor task identifier and a successor task identifier, used to describe four types of dependencies between tasks. A "Complete-Start" relationship indicates that the successor task can only begin after the predecessor task is completed; for example, the foundation concrete pouring must be completed before the foundation reinforcement binding can begin. A "Start-Start" relationship indicates that the successor task can only begin after the predecessor task has started; for example, the main tower reinforcement binding can begin simultaneously after the main tower formwork installation has started. A "Complete-Complete" relationship indicates that the successor task can only be completed after the predecessor task is completed; for example, the formwork removal task can only be completed after the concrete curing is completed. A "Start-Complete" relationship indicates that the successor task can only be completed after the predecessor task has started; for example, the equipment debugging task can only be completed after the temporary power connection has begun. In this embodiment, a total of 312 dependency records were collected.

[0065] The collection of constraint data covers time window constraints, resource capacity constraints, and milestone constraints. Each constraint record includes the following fields: constraint type and constraint content. The earliest start time constraint indicates that a task cannot start earlier than this time, for example, "The earliest start time for T-ST-045 is 2025-04-15 08:00:00," because the critical materials required for the task will only arrive after this time. The latest completion time constraint indicates that a task must be completed before this time, for example, "The latest completion time for T-ST-089 is 2025-08-20 18:00:00," because this task is on the critical path and subsequent tasks are affected by seasonal water level changes. The maximum available resource quantity constraint indicates the maximum number of resources of the same type that can be called up simultaneously, for example, "The maximum available quantity of lifting equipment is 4 units." The stage milestone node constraint indicates the time requirements that critical nodes in a specific stage must be achieved, for example, "The main tower capping node must not be later than 2025-09-30."

[0066] The process of building the initial project's full-process knowledge graph is as follows.

[0067] Each of the 187 collected tasks was mapped to a task entity node in the knowledge graph. Each task entity node was assigned the following attributes: a unique task identifier attribute storing a string value of "T-Phase Code-Three-digit Serial Number", such as "T-FD-001"; a task name attribute storing a standard construction terminology string, such as "Pile Foundation Positioning and Layout"; a task phase attribute storing a phase enumeration value, including "Initiation Phase", "Design Phase", "Procurement Phase", "Construction Phase", "Monitoring Phase", and "Finishing Phase"; an estimated task duration attribute storing a numerical duration value in hours; a task required skill type attribute storing a list of skill types, with one task potentially corresponding to multiple skill type requirements; and a task required skill level attribute storing a list of corresponding skill levels, with each level value corresponding to a skill type.

[0068] Each of the 63 collected resources is mapped to a resource entity node in the knowledge graph. Each resource entity node is assigned the following attributes: The resource unique identifier attribute stores a string value of "R-type code-two-digit serial number", for example, "R-PL-03"; the resource name attribute stores a string value, for example, "No. 2 pile foundation construction team"; the resource type attribute stores an enumerated value of the type, including "construction team", "supervisor", "crane equipment", "concrete pump truck", and "surveying instrument"; the resource available time period attribute stores a list of date ranges; the resource skill type attribute stores a list of skill types possessed by the resource; the resource skill level attribute stores a list of skill levels corresponding to the skill type; and the resource unit time cost attribute stores a numerical cost value in yuan / hour.

[0069] Based on the collected 312 dependency relationship data, directed dependency edges are established between task entity nodes. For each dependency relationship record, the task entity node corresponding to the preceding task identifier and the task entity node corresponding to the following task identifier are located, and a dependency edge is created between these two task entity nodes, pointing from the preceding task entity node to the following task entity node. The attributes of this dependency edge include dependency type, with values ​​of "Complete-Start Type", "Start-Start Type", "Complete-Complete Type", or "Start-Complete Type".

[0070] Based on the skill type and skill level required by the task, assignable edges are established between task entity nodes and resource entity nodes. Specifically, for each skill type requirement of a task entity node, all resource entity nodes are traversed. If a resource entity node's resource skill type list contains that skill type, and the resource entity node's skill level for that skill type is greater than or equal to the task's required skill level, then an assignable edge is created between the task entity node and that resource entity node. If a task has multiple skill type requirements, assignable edges are only established between resource entity nodes that simultaneously satisfy the matching conditions for all skill types and skill levels.

[0071] Each constraint condition in the collected constraint data is represented as a constraint rule node. For example, "The earliest start time of T-ST-045 is 2025-04-15 08:00:00" is converted into a constraint rule node. The attributes of this constraint rule node include the constraint type "earliest start time constraint" and the constraint content "2025-04-15 08:00:00". This constraint rule node is connected to the task entity node with the task identifier "T-ST-045" by applying a relational edge. For the maximum available resource quantity constraint, the constraint rule node is connected to the set of resource entity nodes associated with the corresponding resource type by applying a relational edge.

[0072] The initial project lifecycle knowledge graph constructed in this way is formally represented as follows:

[0073]

[0074] in, This represents the set consisting of all 187 task entity nodes. This represents the set consisting of all 63 resource entity nodes. This represents the set of all constraint rule nodes. This represents the set of dependency edges between task entity nodes; in this embodiment, it contains 312 dependency edges. This represents the set of assignable relational edges between task entity nodes and resource entity nodes. In this embodiment, it contains 1568 assignable relational edges. This represents the set of applicable relational edges between constraint rule nodes and task entity nodes or resource entity nodes. In this embodiment, it contains 45 applicable relational edges.

[0075] Step 2: Based on the initial project's full-process knowledge graph, construct a multi-objective optimization scheduling model;

[0076] Extract the data required for modeling from the initial project lifecycle knowledge graph constructed in step 1.

[0077] Extract task set The total number of tasks is n=187. Each task... For a task entity node in the corresponding knowledge graph, the unique identifier of the task follows the unique identifier attribute value of the task entity node.

[0078] Extract resource collection The total number of resources is m=63. Each resource... This corresponds to a resource entity node in the knowledge graph.

[0079] Extract the dependency matrix P between tasks, with dimension 1. Traverse all dependency edges in the knowledge graph. For each dependency edge pointing from the preceding task entity node to the following task entity node, if the dependency type attribute of the edge is "Completion-Start Type", then assign a value of 1 at the intersection of the row corresponding to the preceding task and the column corresponding to the following task. ;otherwise For task pairs that do not depend on relational edges for connection, In this embodiment, the dependency matrix P contains 312 elements with a value of 1.

[0080] Extract each task Estimated construction period This is read directly from the estimated duration attribute of the task entity node, in hours. For example, the estimated duration of task "T-ST-045" is... .

[0081] Extract task Skill level requirements for each skill type k The required skill type and required skill level attributes are jointly read from the task entity node. In this embodiment, the set of values ​​for skill type k is {1,2,3,4,5,6}, corresponding to "pile foundation construction", "steel structure installation", "concrete pouring", "surveying and setting out", "mechanical and electrical installation", and "welding operation", respectively. If the task If skill type k is not required, then If necessary, The value is the required skill level, and the range is from 1 to 5.

[0082] Extract each resource Set of available resource time periods This is read from the resource availability time period attribute of the resource entity node. Each availability time period is represented as a closed interval, with the starting point of the interval... and the end point All are timestamp values. For example, the resource availability time set for resource "R-PL-03" contains two time periods: [2025-03-01 00:00:00, 2025-06-30 23:59:59] and [2025-08-01 00:00:00, 2025-10-31 23:59:59].

[0083] Extract resources Skill level for each skill type k This is read jointly from the resource entity node's resource skill type attribute and resource skill level attribute. If the resource... If skill type k is not present, then If it is available, then The value is the resource skill level, ranging from 1 to 5.

[0084] Extract the earliest start time constraint from the constraints. And the latest completion time constraint of the task From knowledge graphs and tasks Obtained from the constraint rule nodes applicable to relational edge connections. If the task... If no earliest start time constraint is set, then... Set the overall project start time to 2025-03-01 00:00:00; if the task If no latest completion time constraint is set, then... Set the overall project completion time to 2026-08-22 23:59:59.

[0085] Construct the decision variables for a multi-objective optimization scheduling model. Define binary decision variables. ,when The time indicates the task Allocate resources Execution, when At that time, it was indicated that the task would not be carried out. Allocate resources Execution. Define continuous-time variables. , indicating task The planned start time is in hours from the project's base time. In this example, the base time is set to 2025-03-01 00:00:00.

[0086] The primary optimization objective is to minimize the total project duration. The total project duration is defined as the maximum completion time of all tasks, and the primary optimization objective function is expressed as:

[0087]

[0088] The second optimization objective is to minimize the total project cost. The total project cost is defined as the sum of the execution costs of all tasks. The task execution cost equals the product of the task duration and the unit time cost of the resources after resource allocation. The second optimization objective function is expressed as:

[0089]

[0090] in, Representing resources The unit time cost is expressed in yuan per hour. For example, the unit time cost of resource "R-PL-03" is... .

[0091] The third optimization objective is to maximize resource load balancing. Resource load balancing is characterized by the coefficient of variation of resource utilization distribution; a smaller coefficient of variation indicates a more balanced load. utilization rate Defined as the ratio of the total working time of the resource to the total project duration:

[0092]

[0093] in, This represents the total project duration, which is the maximum time required to complete all tasks.

[0094] Mean of utilization rate of all resources and standard deviation Calculated separately as follows:

[0095]

[0096]

[0097] The third optimization objective function is to maximize load balancing, where the load balancing value ranges from 0 to 1, with a larger value indicating better load balancing.

[0098]

[0099] Constraints for constructing a multi-objective optimization scheduling model.

[0100] Dependency constraints: For all conditions satisfying The task to There must be That is, the completion time of the preceding task must not be later than the start time of the following task.

[0101] Resource capacity constraints: at any given time The same resource can only be allocated to at most one task. This constraint is implemented through resource occupancy checks on the timeline: for each resource... At any point in time Check all that meet the requirements. Task middle The number of elements must be less than or equal to 1.

[0102] Resource availability time constraint: For all conditions that are met The allocation relationship must have resources. A certain available time period This makes the task The entire execution interval falls within this available time period, which satisfies... and If no such available time slot exists, then the allocation relationship... This is an infeasible allocation.

[0103] Skill matching constraint: For all skills that meet the constraint... The allocation relationship must be based on the task. All required skill types k are satisfied Resources The skill level for this skill type is no lower than that for the task. Skill level requirements for this skill type.

[0104] Time window constraint: For each task Its start time must not be earlier than the earliest start time constraint, and its finish time must not be later than the latest finish time constraint, i.e. and .

[0105] Step 3: Use a non-dominated sorting genetic algorithm based on a dual-community cooperative evolution mechanism to solve the multi-objective optimization scheduling model and generate a set of Pareto optimal scheduling schemes;

[0106] This step employs an improved non-dominated sorting genetic algorithm to solve the multi-objective optimization scheduling model constructed in step 2. The core feature of this algorithm is the introduction of a dual-community cooperative evolution mechanism, dividing the population into two sub-communities: an exploratory community and a development community. These two sub-communities evolve in parallel using different genetic operation strategies and achieve information exchange and cooperative search through periodic gene exchange, thus achieving a better balance between global exploration capability and local convergence capability.

[0107] Encoding scheme. A task sequence-resource allocation two-segment chromosome encoding scheme is adopted. Each chromosome consists of two equal-length parts: a first gene segment and a second gene segment.

[0108] The first gene segment is a task priority sequence, with a length equal to the total number of tasks (187). Each gene position in the first gene segment stores a task identifier; for example, the value stored in the 5th gene position is "T-ST-045", indicating the position of the task in the priority sequence. The first gene segment as a whole represents the priority order of task scheduling. During decoding, the start time of tasks is arranged sequentially from left to right, with tasks appearing on the left side of the sequence having higher scheduling priority.

[0109] The second gene segment is the resource allocation sequence, also with a length equal to the total number of tasks (187). The value of the i-th gene position in the second gene segment represents the resource identifier assigned to the i-th task. The i-th task refers to the i-th task determined by the natural ordering of the task unique identifiers, not by priority order. For example, if the value of the 45th gene position is "R-PL-03", it means that the resource "R-PL-03" is assigned to task "T-ST-045". This two-segment encoding scheme can simultaneously express task execution order information and resource allocation decision information on the same chromosome, providing a complete genetic information carrier for subsequent crossover and mutation operations.

[0110] Population initialization and community partitioning. Randomly generated population size is... The initial population was generated by randomly permuting 187 task identifiers for each individual, and by randomly selecting a resource identifier from a set of resources that satisfy skill matching constraints for each task. After the initial population was generated, the 200 individuals were randomly and equally divided into two sub-populations: an exploration community and an exploration community. Contains 100 individuals, developing a community It contains 100 individuals.

[0111] Fitness evaluation. For each individual, based on the scheduling scheme encoded in its chromosome, the task start time and resource allocation are calculated under the premise of satisfying constraints, and then three optimization objective functions are calculated. , , The value of . For individuals that violate the constraints, a penalty function is applied as a fitness penalty. The violation amount of dependency constraints is defined as The unit is hours; the violation of resource capacity constraints is defined as the sum of the amount of over-allocated resources at all times, in resources-hours; the violation of skill matching constraints is defined as the cumulative number of skill level deficiencies. The fitness value after penalty is the original objective function value plus the product of the violation amount and the penalty coefficient. In this embodiment, the penalty coefficient is set to... The magnitude is used to effectively eliminate infeasible solutions.

[0112] Explore community evolution strategies. The first genetic operation strategy is adopted, which promotes extensive search of the solution space with a large variable time.

[0113] The selection process for the exploratory community employs a crowding tournament selection method. Each time, k=5 individuals are randomly selected from the exploratory community, and the crowding distance between these 5 individuals is calculated. The individual with the largest crowding distance is selected to enter the mating pool. The crowding distance is calculated as follows: for each individual, it is sorted according to the values ​​of three optimization objective functions. The difference in objective function between adjacent individuals is calculated, and the sum of the differences across the three objectives is taken as the crowding distance for that individual. A larger crowding distance indicates a sparser distribution of the individual on the Pareto front, and selecting this individual helps maintain population diversity.

[0114] The crossover operation in the community is explored using a two-point crossover strategy. Two parent individuals are selected from the mating pool, and two crossover points are randomly generated. and ,satisfy For the first gene segment, the gene segments between the two parent individuals are exchanged at the crossover point to obtain the first gene segment of the two offspring individuals. For the second gene segment, the same crossover point is used for gene segment exchange. The crossover probability is set as the first crossover probability. .

[0115] The mutation operation for exploring the community employs a uniform mutation strategy. For the first gene segment, a first mutation probability is used. For each gene locus, mutation is performed. During mutation, another gene locus is randomly selected and its task identifier value is swapped with the current gene locus. For the second gene segment, the same first mutation probability is applied. For each gene locus, mutation is performed. During mutation, a new resource identifier is randomly selected from the set of resources that can be matched for the task to replace the current value. The first mutation probability of 0.15 is higher than the standard mutation probability value of 0.01 to 0.05 for conventional genetic algorithms, to ensure that the explored community has a stronger ability to perturb the solution space.

[0116] Develop community evolution strategies. Develop communities. A second genetic operation strategy is adopted, which performs a fine search in the local optimum region with a smaller variable time.

[0117] The selection operation for the development community also adopts the crowding tournament selection, randomly selecting k=5 individuals each time, and selecting the individual with the largest crowding distance to enter the mating pool.

[0118] The crossover operation in the development community adopts a simulated binary crossover strategy. For resource allocation decisions in the second gene segment, the simulated binary crossover generates offspring values ​​as follows: Let the gene values ​​of the two parent individuals be... and Generate a random number u that is uniformly distributed in the interval [0,1]. Then the offspring value If u > 0.5, then ,in In this embodiment, the distribution index is used. The value is set to 2. The crossover probability is set to the second crossover probability. .

[0119] The mutation operation for community development employs a multinomial mutation strategy. For each gene locus in the second gene segment, a second mutation probability is used. Mutation occurs. During mutation, a new value is generated within the neighborhood of the current gene value according to a multinomial distribution, where the exponent parameter of the multinomial distribution is... The value is set to 20 to control the variation length to be relatively small. The second mutation probability of 0.02 is significantly lower than the first mutation probability of 0.15 in the exploratory community, ensuring that the development community performs a refined local search near the current optimal solution rather than making large jumps.

[0120] Inter-community gene exchange mechanisms. Every [period] Each generation performs a gene exchange operation between the exploratory and developed communities. In this embodiment, the initial gene exchange interval is set to... generation.

[0121] The specific method of gene exchange operation is as follows: First, non-dominated ordination is performed on the exploratory community and the development community respectively, and the non-dominated frontier level is selected from the exploratory community. The first M=5 individuals are selected, and those at the non-dominant frontier level are chosen from the developed community. The first M=5 individuals are selected. Then, 5 individuals selected from the exploration community are added to the development community, and 5 individuals selected from the development community are added to the exploration community. To keep the size of each sub-community unchanged, the 5 individuals with the lowest non-dominance front level are removed from the exploration community, and the same applies to the development community.

[0122] Gene exchange interval An adaptive strategy is employed for dynamic adjustment. Every 10 generations, the intersection ratio of the non-dominated frontiers between the exploratory and exploitative communities is calculated; that is, the ratio of non-dominated frontiers simultaneously appearing in both sub-communities at their respective non-dominated frontier levels. The proportion of identical individuals within a subcommunity. When the overlap ratio exceeds a preset threshold... When the search directions of the two sub-communities have become relatively similar, the gene exchange interval can be increased to [value missing]. This reduces unnecessary individual exchange costs. When the overlap ratio is below a threshold... When this occurs, it indicates a significant difference in the search directions of the two sub-communities; in this case, the gene exchange interval should be reduced to [value missing]. This will enhance information exchange and collaborative search.

[0123] Non-dominated ranking and elite preservation. Non-dominated ranking is performed separately for exploratory and developmental communities after evolutionary operations. The process is as follows: for each individual in the community, the number of individuals dominated by other individuals is calculated, and individuals with a dominance count of 0 are placed in the first non-dominated frontier level. After temporarily removing individuals from the first non-dominated frontier level, the dominance of the remaining individuals is recalculated, and individuals with a new dominance of 0 are moved to the second non-dominated frontier level. This process continues until all individuals are classified into different non-dominated frontier levels. .

[0124] The elite retention strategy is: for each subpopulation, from Individuals are selected sequentially to enter the next generation of the population until the maximum subpopulation size of 100 is reached. If a non-dominant frontier level is selected... Overcrowding may occur, that is, if... If all individuals are selected, the number exceeds 100, then the calculation will be performed. For each individual, the crowding distance is considered, and individuals with larger crowding distances are prioritized for retention until 100 individuals are selected.

[0125] Iteration termination and Pareto optimal solution extraction. Repeat the above fitness evaluation, community evolution, gene exchange, and elite preservation processes until the preset maximum number of iterations is reached. After the iteration, all 200 individuals from the exploratory and exploitative communities are merged, and these individuals are re-ranked using non-dominated sorting. Those at the first non-dominated frontier are then extracted. All individuals constitute the Pareto optimal scheduling scheme set. This embodiment, after 500 iterations, yields the Pareto optimal scheduling scheme set. It contains 32 non-dominated scheduling schemes, which are not mutually dominant on the three optimization objectives and together constitute the Pareto front of this multi-objective optimization problem.

[0126] Step 4: Select an implementation scheme from the Pareto optimal scheduling scheme set and issue it for execution, while simultaneously collecting event logs of the project execution process;

[0127] The Pareto optimal scheduling scheme set containing 32 scheduling schemes generated in step 3. In this study, a multi-criteria decision-making method based on the distance to ideal points was adopted to select the final implementation scheme.

[0128] First, calculate the ideal value vectors for the three optimization objectives. Iterate through all 32 schemes in the Pareto optimal scheduling scheme set, recording the optimal value for each objective: the ideal value for the first optimization objective is to minimize the total project duration. For all solutions in the set The minimum value in this embodiment Equivalent to 528 calendar days; the second optimization objective is to minimize the ideal value of the total project cost. For all solutions in the set The minimum value in this embodiment The third optimization objective is to maximize the ideal value of resource load balancing. For all solutions in the set The maximum value in this embodiment This constitutes the ideal value vector. .

[0129] Then, the objective function value of each scheme is normalized. For scheme s, its normalized objective vector is: ,in and These are the maximum and minimum values ​​of the first objective in the set, and the others are similar. After normalization, the value range of each objective is mapped to the interval [0,1], and all three objectives are transformed into a form that optimizes towards the minimum value.

[0130] Calculate the normalized target vector to the ideal vector for each scheme. Euclidean distance:

[0131]

[0132] Select Euclidean distance The smallest possible solution is selected as the final implementation plan. In this embodiment, the selected final implementation plan corresponds to a total project duration of 12,960 hours (equivalent to 540 calendar days), a total project cost of 275.6 million yuan, and a resource load balance of 0.791. This solution achieves a relatively good level in all three optimization objectives and exhibits good overall balance.

[0133] The selected final implementation plan was distributed to the project execution system. The final implementation plan specified a defined planned start time for each of the 187 tasks. And the assigned resource identifier. For example, the planned start time for task "T-ST-045" is 08:00:00 on May 12, 2025, and the assigned resource is "R-PL-03", which is the No. 2 pile foundation construction team.

[0134] During project execution, event logs are collected in real time through a data acquisition interface deployed on the construction site management platform. This data acquisition interface interfaces with the labor real-name attendance system, construction machinery and equipment monitoring terminals, material arrival acceptance system, and quality inspection system to achieve automatic event data collection.

[0135] Each event record in the project execution process event log contains the following fields:

[0136] The event timestamp field is accurate to the second and is in the format "YYYY-MM-DDHH:MM:SS", for example, "2025-05-12 08:03:15".

[0137] The task identifier field associated with the event stores the unique identifier of the task that triggered the event, such as "T-ST-045".

[0138] The event type field can take one of the following values: "task start event", "task completion event", "task pause event", "task resume event", "resource allocation event", "resource release event", or "task change event".

[0139] The resource identifier field associated with the event stores the unique identifier of the resource associated with the event. For task start and task completion events, this field records the resource identifier that executes the task; for resource allocation and resource release events, this field records the resource identifier that is allocated or released.

[0140] The event supplementary information field stores additional information related to the event in key-value pairs. For example, for a task pause event, the event supplementary information includes a "Pause Reason" key and a corresponding pause reason value, such as "Work stoppage due to weather" or "Materials not arrived"; for a task change event, the event supplementary information includes a "Change Content" key and a change content description value.

[0141] The collected event logs are stored as tracks. Each track corresponds to the execution process of a project instance; in this embodiment, it represents the complete execution process of a bridge construction project from start to finish. A track consists of a sequence of events arranged in ascending order of event timestamps, formally represented as... ,in Let represent the i-th event record, and q represent the total number of events in this trajectory. In this embodiment, a total of q=14583 event records were collected during the first three months of project execution, forming a complete project execution trajectory.

[0142] Step 5: Analyze the project execution process event logs based on Petri net process mining technology, identify execution deviations and process bottlenecks, generate adaptive scheduling adjustment instructions, and update the project's full-process knowledge graph;

[0143] Extract actual task execution data. Extract the actual execution data for each completed task from the collected project execution process event logs.

[0144] For each completed task The "Task Start Event" and "Task Completion Event" records corresponding to this task were located in the event log. The actual task duration... The calculation method is as follows:

[0145]

[0146] The calculation results are in hours. For example, if the task start event timestamp for task "T-ST-045" is 2025-05-12 08:03:15 and the task completion event timestamp is 2025-05-17 14:22:30, then the actual task duration is... .

[0147] Read the resource identifier actually allocated to the task from the resource identifier field associated with the "Task Start Event". The event log is used to calculate the duration of each resource used during the entire execution period of the task, thus obtaining the actual resource consumption time of the task.

[0148] Discovering the actual execution process model. A Petri net-based process discovery algorithm is used to discover the actual execution process model from the event log traces. This embodiment uses the InductiveMiner algorithm as the process discovery algorithm, which can robustly discover workflow networks containing four basic process structures: sequential, parallel, selection, and cyclic.

[0149] The actual execution process model is represented in the form of a workflow network, formally defined as a quadruple. .

[0150] Wherein, P represents a finite set of libraries. In this embodiment, the number of libraries is 215, corresponding to various state conditions during the project execution process, such as "pile foundation construction completed", "reinforcement binding ready", "concrete curing period completed", etc.

[0151] T represents a finite set of transitions. In this embodiment, there are 187 transitions, which correspond one-to-one with 187 construction tasks.

[0152] This represents the set of directed arcs connecting places and transitions, describing the flow of the execution process. If there is a directed arc from place p to transition t, it means that the state condition represented by place p is a prerequisite for transition t; if there is a directed arc from transition t to place p, it means that the state condition represented by place p will be generated after transition t occurs. In this embodiment, there are a total of 1342 directed arcs.

[0153] The initial identifier describes the initial state before project execution. In this embodiment, the initial identifier is a "project startup" repository containing a token.

[0154] The specific execution steps of the process discovery algorithm are as follows.

[0155] The first step is to iterate through the 14,583 event records in the event log track and count the frequency of follow-up relationships between tasks. If the event sequence in the track is... If there is a follow-up relationship between task A and task B, then the corresponding count value in the task relationship matrix will be incremented by 1.

[0156] The second step is to identify the flow relationship type between tasks based on the frequency of follow-up relationships. If task B always appears after task A and task A always appears before task B, it is identified as a sequential relationship; if task A and task B appear in the log in any order but not simultaneously, it is identified as a selection relationship; if task A and task B can appear in any alternation and are both triggered by the same event or jointly trigger the same event, it is identified as a parallel relationship; if task A repeatedly appears in a trajectory to form a self-loop, it is identified as a cyclic relationship.

[0157] The third step involves recursively constructing the place nodes and transition nodes of the workflow network based on the identified relationship types, and establishing the corresponding flow relationships. For sequential relationships, a place is inserted between two transitions and connected by a directed arc; for selection relationships, branching places and merging places are created to connect transitions of multiple branches in parallel; for parallel relationships, parallel branching places and parallel merging places are created, and transitions are connected in a mesh network through places.

[0158] The fourth step is to perform structured verification on the constructed workflow network. This involves checking whether the workflow network meets the reachability requirements of Petri nets, i.e., whether it is possible to reach all places and transitions from the initial identifier through the sequence of transitions; and checking whether the workflow network meets the boundedness requirements, i.e., whether there is an upper bound on the number of tokens in any place. After verification, the workflow network discovered in this embodiment meets both the reachability and boundedness requirements.

[0159] Compliance checks identify execution deviations. The discovered workflow networks... Compared with the expected process model constructed based on the dependency matrix P in step 2 Alignment comparisons are performed, and execution deviations are identified through compliance checks. Compliance checks include two dimensions: detection of deviations in task execution order and detection of deviations in task duration.

[0160] Task execution order deviation detection: replaying event log traces to the expected process model The system detects deviations during replay. When the actual order of tasks in the trajectory differs from the order specified by the dependency edges in the expected process model, a deviation event is recorded. The types of deviations and their judgment criteria are as follows: Early task execution deviation: The actual task A begins execution before the expected preceding task B is completed; Delayed task completion deviation: The actual completion time of task A is later than the completion time constraint of task A in the expected process model; Task skipping deviation: A task that is specified to be executed in the expected process model does not appear in the actual trajectory; Task repeated execution deviation: A task that is specified to be executed only once in the expected process model appears multiple times in the actual trajectory.

[0161] In this embodiment, 23 deviation events were detected during the compliance check, including 5 deviations of task early execution, 12 deviations of task delayed completion, 1 deviation of task skipping, and 5 deviations of task repeated execution. For each deviation event, the deviation type, the task identifier in which the deviation occurred, and the timestamp of the deviation occurrence were recorded.

[0162] Task schedule deviation detection: For each completed task Calculate the project schedule deviation rate :

[0163]

[0164] in The actual duration of the task. Estimate the project duration for the tasks collected in Step 1. When the project duration deviation rate... The absolute value exceeds the preset threshold At that time, determine the task Significant time deviations exist. For example, the actual time for task "T-ST-045" was 126.32 hours, while the estimated time was 96 hours, resulting in a time deviation rate of [missing information]. If the deviation exceeds the 20% threshold, the task is deemed to have a significant schedule delay.

[0165] Performance analysis identifies process bottlenecks. Workflow network... Each change in For each construction task, the following three performance indicators are calculated to identify process bottlenecks.

[0166] Metric 1 is the average waiting time for the task. The average task wait time is defined as the mean of the differences between the actual start time and the planned start time of a task, reflecting the length of time a task is forced to wait due to insufficient resources or delays in preceding dependencies.

[0167]

[0168] in, Indicates task In this embodiment, each task is executed once, as recorded in the event log. ; Indicates task No. The actual start time of the next execution; Indicates task No. The planned start time for this execution is obtained from the implementation plan issued in step 4. For example, if the actual start time of task "T-ST-056" is 11:30:00 on June 2, 2025, and the planned start time is 08:00:00 on May 28, 2025, then the average waiting time for this task is... .

[0169] Indicator 2 is the cumulative delay of the process path in which the task is located. Cumulative delay is defined as the delay from the start of the process to the task. The sum of the single-execution latency of all tasks on the critical path:

[0170]

[0171] in, Indicates the process from its starting point to the task. The set of all tasks on the critical path, the critical path is formed by the workflow network. From initial repository to task Determine the path with the longest total duration among all paths for the strain transition; Indicates task The single execution latency, i.e., the task The difference between the actual completion time and the planned completion time. Indicator three is the intensity of resource competition. Resource competition intensity is defined as the task During the waiting period, the number of other tasks concurrently requesting the same resource is equal to the number of tasks. The ratio of waiting time:

[0172]

[0173] in, Let be the average waiting time for task t. The "number of tasks requesting the same resources as task t" in the numerator refers to the number of other tasks that were allocated the same resource identifier as task t during that time period.

[0174] A task that meets any one of the following three conditions is identified as a process bottleneck: average task wait time. Ranked among the top 187 tasks In this embodiment, K=15, which represents the top 28 tasks; cumulative latency. Ranked among the top 187 tasks Similarly, tasks ranked in the top 28 will be selected; resource competition intensity Exceeding the preset threshold In this embodiment .

[0175] This embodiment identifies six bottleneck tasks after calculation: task "T-ST-023" main tower climbing formwork installation, task "T-ST-045" main tower third segment rebar binding, task "T-ST-067" stay cable tensioning preparation, task "T-ST-089" bridge deck pavement pouring, task "T-ST-112" auxiliary facility welding, and task "T-ST-145" electrical system commissioning.

[0176] Generate adaptive scheduling adjustment instructions. Based on execution deviations identified through compliance checks and process bottlenecks identified through performance analysis, generate adaptive scheduling adjustment instructions. The instructions are generated according to the following rules.

[0177] Rule 1: When a deviation from the planned early execution of a task is detected, and this deviation causes a resource conflict, a task start time postponement instruction is generated. The task start time postponement instruction includes the target task identifier and the postponed start time, with the postponement amount set to the minimum time interval required to resolve the conflict. For example, if it is detected that task "T-ST-067" started early, causing it to occupy the only cable-stayed tensioning device simultaneously with task "T-ST-066", the generated task start time postponement instruction would be: target task identifier "T-ST-067", and the postponed start time would be 72 hours after the original planned start time, to wait for task "T-ST-066" to complete and release the tensioning device.

[0178] Rule 2: When a task delay deviation is detected, and the schedule deviation rate is... When the delay exceeds a preset threshold of 20%, two types of instructions are generated. The first type of instruction is a start time postponement instruction, which postpones the planned start time of all subsequent tasks affected by the delay of this task by an amount equal to the delay of the preceding task. The second type of instruction is the resource allocation instruction, which allocates parallel execution resources to tasks that have not yet started along the process path where the delayed task is located. For example, the schedule deviation rate for task "T-ST-045" (main tower third segment rebar binding). The threshold of 20% has been exceeded. A start time extension instruction of 30.32 hours is generated for the 12 subsequent tasks affected by this task; simultaneously, a resource allocation instruction is generated to allocate an additional rebar team for the subsequent main tower fourth segment rebar binding task "T-ST-058".

[0179] Rule 3: When a bottleneck task is identified, a bottleneck resolution instruction is generated. Bottleneck resolution instructions include resource allocation instructions and process reconfiguration instructions. Resource allocation instructions allocate resources for parallel execution to the bottleneck task; for example, allocating one tower crane to the bottleneck task "T-ST-023" (main tower climbing formwork installation). Process reconfiguration instructions optimize the pre-dependencies of the bottleneck task; for example, adjusting non-hard dependencies in the pre-dependencies of the bottleneck task "T-ST-089" (bridge deck pavement pouring) to be executed in parallel.

[0180] Rule 4: When the intensity of resource competition When the number of resource conflict resolution tasks exceeds a preset threshold of 0.35 per hour, a resource conflict resolution instruction is generated. This instruction adjusts the priority order of multiple tasks competing for the same resource, placing higher-priority tasks first. Priority is determined by a combination of factors, including the task's location on the critical path, its time-to-delay rate, and the importance of the stage to which it belongs.

[0181] Update the project's full-process knowledge graph. All information extracted and generated during the above analysis will be added as new knowledge and updated to the project's full-process knowledge graph. The update operation includes the following:

[0182] Update Operation 1: Update the attributes of task entity nodes in the knowledge graph. Update the actual task duration attribute to the calculated actual task duration. Update the actual resource allocation attribute of the task to the actual resource identifier. Update the task duration deviation rate attribute to duration deviation rate. For example, update the actual task duration attribute of the task entity node "T-ST-045" to "126.32h", the actual allocated resources attribute to "R-PL-03", and the task duration deviation rate attribute to "31.58%".

[0183] Update Operation 2: Based on the discovered actual flow relationships between tasks in the workflow network, add actual flow relationship edges to the knowledge graph. For task pairs with a direct temporal sequence relationship in the workflow network, create actual flow relationship edges between the corresponding task entity nodes, with the direction of the relationship edge pointing from the preceding task entity node to the following task entity node. In this embodiment, 198 actual flow relationship edges have been added.

[0184] Update Operation 3: Mark the 6 identified bottleneck tasks as bottleneck task node types. Add a bottleneck type attribute and an average waiting time attribute to each bottleneck task entity node. The bottleneck type attribute can be "waiting time bottleneck", "cumulative delay bottleneck", or "resource contention bottleneck". For example, the bottleneck type attribute of task "T-ST-045" is "cumulative delay bottleneck", and the average waiting time attribute is "127.5h".

[0185] Update Operation 4: The 17 generated adaptive scheduling adjustment instructions are added to the knowledge graph as scheduling adjustment instruction entity nodes. Each scheduling adjustment instruction entity node has an instruction type attribute, an instruction content attribute, and a generation timestamp attribute. The scheduling adjustment instruction entity nodes are connected to the target task entity nodes through adjustment object relationship edges; and the scheduling adjustment instruction entity nodes are connected to the deviation event entity nodes or process bottleneck task entity nodes that triggered the adjustment through generation basis relationship edges.

[0186] Update Operation 5: Increment the version number of the knowledge graph from the initial version "V1.0" to "V2.0", and record the version update timestamp "2025-07-15 16:30:00" in the knowledge graph metadata to form a knowledge graph version record with timestamps, which is convenient for tracing the complete evolution process of knowledge management throughout the project.

[0187] Iterative loop. Using the updated project knowledge graph (version "V2.0") as input for step 2, steps 2 through 5 are re-executed, forming a closed-loop iterative process of "modeling—optimization—execution—analysis—update—re-optimization". In this embodiment, three complete closed-loop iterations were performed. After the first iteration, the actual total project duration was shortened by 28 calendar days compared to the initial plan; after the second iteration, the standard deviation of resource utilization decreased by 0.12, resulting in a more balanced load; after the third iteration, the number of execution deviation events decreased from 23 to 8, significantly improving the overall execution stability of the project.

[0188] Comparative Example

[0189] To verify the technical effectiveness of this embodiment, comparative experiments were conducted using Comparative Example 1, Comparative Example 2, and Comparative Example 3. All three comparative examples used the same dataset from a bridge construction project, containing 187 tasks, 63 resources, 312 dependencies, and 45 constraints. The three comparative examples were run in the same computing environment as this embodiment: a 64-core server with a CPU clock speed of 3.2 GHz and 256 GB of memory.

[0190] Comparative Example 1 employs a traditional resource-constrained project scheduling method. This method uses a priority-based critical path approach to generate an initial scheduling plan, without multi-objective optimization, focusing solely on minimizing the project duration. Deviations during project execution are manually assessed and adjusted by the project manager. It does not utilize knowledge graphs for knowledge accumulation or process mining techniques for deviation analysis. The specific steps of Comparative Example 1 are as follows: First, calculate the earliest and latest start times for each task based on dependencies to identify the critical path; second, allocate available resources to each task according to a priority rule of critical path first, followed by earliest start time; third, distribute the generated plan for execution and manually record execution deviations; fourth, when the deviation exceeds 5 calendar days, hold a scheduling meeting to manually adjust subsequent plans.

[0191] Comparative Example 2 employs a static multi-objective optimization scheduling method. This method uses a standard non-dominated sorting genetic algorithm to generate a set of Pareto optimal scheduling schemes in the initial project phase, but does not employ a dual-community collaborative evolution mechanism; once a scheme is selected, it is executed in a fixed manner without adaptive adjustments during execution; and Petri net process mining techniques are not used for execution process analysis. The specific steps of Comparative Example 2 are as follows: First, a multi-objective optimization scheduling model is constructed using the same method as in Step 2; Second, a standard non-dominated sorting genetic algorithm is used to solve the problem, with a population size of 200, a maximum number of iterations of 500, a crossover probability of 0.9, and a mutation probability of 0.05, without community partitioning or gene exchange; Third, the scheme with the smallest ideal point distance from the Pareto front, as in Step 4, is selected and executed; Fourth, when deviations occur during execution, only the start time of the directly affected subsequent tasks is manually adjusted, without global re-optimization.

[0192] Comparative Example 3 employs a single-population evolution and static log analysis method. This method uses a non-dominated sorting genetic algorithm for a single population during the scheduling optimization phase; it uses simple statistical analysis instead of Petri net process mining during the execution analysis phase; and it does not use a knowledge graph continuous update mechanism. The specific steps of Comparative Example 3 are as follows: First, a multi-objective optimization scheduling model is constructed using the same method as in Step 2; second, a standard non-dominated sorting genetic algorithm is used to solve the problem, with parameter settings the same as in Comparative Example 2; third, after execution, only simple schedule deviation statistics are performed on the event logs. When the cumulative deviation exceeds a threshold, the complete optimization algorithm is run again to generate a completely new scheduling scheme, without performing local adaptive adjustments.

[0193] Table 1 shows the comparison results of key performance indicators of this embodiment with Comparative Examples 1, 2, and 3 in the whole process management of the project.

[0194] Table 1 Comparison Results of Key Performance Indicators

[0195] Performance indicators Comparative Example 1 Comparative Example 2 Comparative Example 3 This embodiment Total project duration (calendar days) 607 552 548 518 Total project cost (100 million yuan) 3.021 2.812 2.794 2.746 Resource load balancing 0.542 0.713 0.725 0.836 Total number of execution deviation events (number of events) 47 38 35 8 Time taken to generate scheduling scheme (min) not applicable 186 192 142 Adaptive adjustment of response time (h) 48 24 12 2 Iterative convergence to a stable frontier algebra not applicable 423 407 278 Number of Pareto front solutions not applicable 18 20 32

[0196] As shown in Table 1, this embodiment outperforms the three comparative examples in all performance indicators. Regarding the total project duration, this embodiment is 518 calendar days, which is 89 calendar days shorter than Comparative Example 1, 34 calendar days shorter than Comparative Example 2, and 30 calendar days shorter than Comparative Example 3. Regarding the total project cost, this embodiment is 274.6 million yuan, which is 27.5 million yuan lower than Comparative Example 1, 6.6 million yuan lower than Comparative Example 2, and 4.8 million yuan lower than Comparative Example 3. In terms of resource load balancing, this embodiment achieves 0.836, significantly higher than the three comparative examples, indicating that this embodiment can more effectively balance the utilization rate of various resources and reduce the coexistence of resource idleness and excessive strain.

[0197] In terms of dynamic response capability, the adaptive adjustment response time of this embodiment is only 2 hours, while that of Comparative Example 1 is 48 hours, Comparative Example 2 is 24 hours, and Comparative Example 3 is 12 hours. This advantage is due to the closed-loop iterative mechanism of Petri net process mining and knowledge graph update in step 5. When an execution deviation occurs, the system can automatically analyze the cause of the deviation and generate adjustment instructions without manual intervention and global re-optimization calculation.

[0198] In terms of optimization efficiency, the algorithm in this embodiment requires 278 generations to converge to a stable Pareto front, while the single-population algorithm requires more than 400 generations, demonstrating the synergistic effect brought about by the dual-community co-evolution mechanism. The exploratory community in the dual communities maintains population diversity and the breadth of the solution space exploration, while the development community focuses on refined searches in locally optimal regions. Through periodic gene exchange, it transmits superior gene regions discovered by the exploratory community to the development community, while the refined solutions searched by the development community are also fed back to the exploratory community as a starting point for further exploration. This division of labor and cooperation mechanism between the two sub-communities improves the overall convergence speed by approximately 31.5% compared to the single-population algorithm, and the final output of 32 Pareto front solutions is richer than the 18 to 20 solutions of the single-population algorithm, providing decision-makers with more diverse optimal solutions.

[0199] Regarding execution stability, after three closed-loop iterations, the total number of execution deviation events in this embodiment decreased from the initial 23 to 8, while the number of deviation events in Comparative Examples 1, 2, and 3 remained above 35. This result indicates that the knowledge graph continuous updating and process mining analysis mechanism of this embodiment can effectively accumulate experiential knowledge, enabling the scheduling scheme to be gradually optimized as the project progresses, ultimately achieving a stable and efficient execution process.

[0200] This invention encompasses any substitutions, modifications, equivalent methods, and solutions made within the spirit and scope of this invention. To provide the public with a thorough understanding of this invention, specific details are described in detail in the following preferred embodiments; however, those skilled in the art will fully understand the invention even without these details. Furthermore, to avoid unnecessary misunderstanding of the essence of this invention, well-known methods, processes, procedures, components, and circuits are not described in detail.

[0201] The above description is only a preferred embodiment of the present invention. It should be noted that for those skilled in the art, several improvements and modifications can be made without departing from the principle of the present invention, and these improvements and modifications should also be considered within the scope of protection of the present invention.

Claims

1. A method for intelligent optimization scheduling and management throughout the entire project lifecycle, characterized in that, Includes the following steps: Step 1: Collect basic data for the entire project process and construct an initial knowledge graph of the entire project process. The basic data for the entire project process includes task data, resource data, dependency data, and constraint data. Map the task data to task entity nodes and the resource data to resource entity nodes. Establish directed dependency edges between the task entity nodes based on the dependency data. Establish assignable relationship edges between the task entity nodes and the resource entity nodes based on the skill types required by the tasks in the task data and the skill types to which the resources belong in the resource data. Step 2: Based on the initial project full-process knowledge graph, extract the task set, resource set, dependency matrix, estimated task duration, resource availability time period set, skill requirement level and constraints, and construct a multi-objective optimization scheduling model that includes minimizing the total project duration optimization objective, minimizing the total project cost optimization objective, and maximizing the resource load balancing optimization objective; Step 3: The multi-objective optimization scheduling model is solved by using a non-dominated sorting genetic algorithm based on the dual-community cooperative evolution mechanism. The population is divided into two sub-communities: an exploratory community and a development community. The exploratory community adopts the first genetic operation strategy, and the development community adopts the second genetic operation strategy. The two sub-communities evolve in parallel and achieve cooperative search through periodic gene exchange. After the iteration, the Pareto optimal scheduling scheme set is extracted. Step 4: Select an implementation scheme from the Pareto optimal scheduling scheme set and issue it for execution. Simultaneously collect the project execution process event log. Each event record in the project execution process event log includes the event occurrence timestamp, the task identifier associated with the event, the event type, and the resource identifier associated with the event. Step 5: Analyze the event logs of the project execution process based on Petri net process mining technology to discover the actual execution process model, identify execution deviations through compliance checks, identify process bottlenecks through performance analysis, generate adaptive scheduling adjustment instructions, and update the initial project full-process knowledge graph based on the actual execution process model, the execution deviations, the process bottlenecks, and the adaptive scheduling adjustment instructions. After the update, iteratively execute steps 2 to 5.

2. The intelligent optimization scheduling and management method for the entire project process according to claim 1, characterized in that, The task data in step 1 includes a unique task identifier, task name, task stage, estimated task duration, required skill type, and required skill level; the resource data includes a unique resource identifier, resource name, resource type, available resource time period, required skill type, skill level, and unit time cost; the dependency data includes predecessor and successor task identifiers, used to describe the completion-start, start-start, completion-completion, and start-completion relationships between tasks; the constraint data includes the earliest start time constraint, the latest completion time constraint, the maximum available resource quantity constraint, and stage milestone node constraints. When mapping each task to a task entity node in the initial project's full-process knowledge graph, the attributes of the task entity node include the task's unique identifier, the task name, the stage to which the task belongs, the estimated duration of the task, the skill type required by the task, and the skill level required by the task; when mapping each resource to a resource entity node in the initial project's full-process knowledge graph, the attributes of the resource entity node include the resource's unique identifier, the resource name, the resource type, the available time period of the resource, the skill type to which the resource belongs, the skill level of the resource, and the unit time cost of the resource. Based on the preceding task identifier and the following task identifier in the dependency relationship data, a directed dependency relationship edge is established between the preceding task entity node and the following task entity node. The attributes of the dependency relationship edge include the dependency type, which is a complete-start type, a start-start type, a complete-complete type, or a start-complete type. Based on the skill type and skill level required for the task, an assignable relation edge is established between the task entity node and a resource entity node with a matching skill type and a skill level not lower than the skill level required for the task. Each constraint condition in the constraint data is represented as a constraint rule node, and the constraint rule node is connected to the corresponding task entity node or resource entity node by applying relational edges.

3. The intelligent optimization scheduling and management method for the entire project process according to claim 1, characterized in that, The construction process of the multi-objective optimization scheduling model in step 2 specifically includes: Extract task sets from the initial project's full-process knowledge graph. Where n represents the total number of tasks; extract resource set Where m represents the total number of resources; extract the dependency matrix P, where Indicates task Must be in the task Complete before starting. Indicates task With the task There is no finish-start type dependency between them; extract each task. Estimated construction period and tasks Skill level requirements for each skill type k Extract each resource Set of available resource time periods and resources Skill level for each skill type k Extract the earliest start time constraint from the constraints. And the latest completion time constraint of the task ; Construct decision variables , Indicates the task Allocate resources implement, Indicates not to carry out the task Allocate resources Execute; build each task start time variable ; The primary optimization objective is to minimize the total project duration, denoted as: The second optimization objective is to minimize the total project cost, expressed as: ,in Representing resources The unit time cost; the third optimization objective is to maximize resource load balancing, expressed as... ,in This represents the variance of the utilization rate of each resource. This represents the average utilization rate of each resource. utilization rate Defined as , Indicates the total project duration; The constraints for constructing the multi-objective optimization scheduling model include: dependency constraints, for all... The task to ,have Resource capacity constraints, at any given time Allocate resources The number of tasks does not exceed 1; resource availability time constraints apply to all... Task Resources must exist. A certain available time period , making and Skill matching constraints, for all The allocation relationship must satisfy... This holds true for all skill types k; time window constraint. and .

4. The intelligent optimization scheduling and management method for the entire project process according to claim 1, characterized in that, The non-dominated sorting genetic algorithm based on the dual-community cooperative evolution mechanism described in step 3 adopts a task sequence-resource allocation dual-segment chromosome encoding scheme. Each chromosome consists of a first gene segment and a second gene segment. The first gene segment is a task priority sequence with a length equal to the total number of tasks n. Each gene position in the first gene segment stores a task identifier. The first gene segment represents the priority order of task scheduling. The second gene segment is a resource allocation sequence with a length equal to the total number of tasks n. The value of the i-th gene position in the second gene segment represents the resource identifier allocated to the i-th task. After generating the initial population, the initial population is randomly and equally divided into exploratory communities. With development clusters The exploratory community employs a first genetic operation strategy, which includes: a selection operation using a crowding tournament selection, where k individuals are randomly selected from the exploratory community each time, and the individual with the largest crowding distance is selected to enter the mating pool; and a crossover operation using a two-point crossover strategy, with the crossover probability being the first crossover probability. The mutation operation employs a uniform mutation strategy, with the mutation probability being the first mutation probability. The first mutation probability The value is higher than the preset standard mutation probability threshold; The developed community employs a second genetic operation strategy, which includes: a crowding tournament selection operation for the selection operation; and a simulated binary crossover operation with a crossover probability equal to the second crossover probability. The mutation operation employs a polynomial mutation strategy, with the mutation probability being the second mutation probability. The second mutation probability The value is lower than the first mutation probability. ; During the evolution, every Gene exchange operations are performed between the exploration community and the development community. The gene exchange operation is as follows: the top M individuals with the highest non-dominance front level are selected from the exploration community and the development community respectively, the selected M individuals are added to another sub-community at the same time, and the same number of individuals with the lowest non-dominance front level are removed from the receiving sub-community. The value is dynamically adjusted through an adaptive strategy. When the intersection ratio of the non-dominant frontier between the exploratory community and the developing community exceeds a threshold... Time increases When the intersection ratio is lower than the threshold Time decrease ; After the evolutionary operation is completed, the exploratory community and the development community are respectively subjected to non-dominated ordination, and individuals are divided into different non-dominated frontier levels. ,from Individuals are selected sequentially to enter the next generation of the population until the subpopulation size reaches its maximum. If a non-dominant frontier level is selected... If the number of passengers exceeds the limit, then calculate... The crowding distance of each individual is considered, and individuals with larger crowding distances are prioritized for retention; Iterate until the preset maximum number of iterations is reached. Merge all individuals from the exploratory community and the developed community, and extract the non-dominant frontier level. All individuals constitute the Pareto optimal scheduling scheme set.

5. The intelligent optimization scheduling and management method for the entire project process according to claim 1, characterized in that, In step 4, the method for selecting an implementation scheme from the Pareto optimal scheduling scheme set is as follows: using a multi-criteria decision-making method based on ideal point distance, the Euclidean distance from each scheme in the Pareto optimal scheduling scheme set to the three optimization objective ideal value vectors is calculated, and the scheme with the smallest Euclidean distance is selected as the final implementation scheme. The three optimization objective ideal value vectors are composed of the minimum value of the optimization objective of minimizing the total project duration, the minimum value of the optimization objective of minimizing the total project cost, and the maximum value of the optimization objective of maximizing resource load balance in the Pareto front. The final implementation plan is then distributed to the project execution system, wherein a specific start time and allocated resources are specified for each task in the final implementation plan; During project execution, event logs are collected in real time through a data acquisition interface. Each event record in the event log includes an event timestamp, the task identifier associated with the event, the event type, the resource identifier associated with the event, and additional event information. The event types include task start events, task completion events, task pause events, task resumption events, resource allocation events, resource release events, and task change events. The collected project execution process event logs are stored in units of trajectories. Each trajectory corresponds to the execution process of a project instance. Each trajectory consists of a sequence of events arranged in ascending order of event timestamps. The trajectories are formally represented as follows: ,in Let represent the i-th event record, and q represent the total number of events in the trajectory.

6. The intelligent optimization scheduling and management method for the entire project process according to claim 1, characterized in that, Step 5, which involves analyzing the project execution process event logs using Petri net process mining technology, includes: Extract the actual task execution data from the project execution process event log for each completed task. Calculate the actual duration of the task. The actual duration of the task Equal to the task The timestamp of the corresponding task completion event minus the task The timestamp of the corresponding task start event is used to record the task. The actual resource identifier allocated With the task The actual resources and man-hours consumed; A Petri net-based process discovery algorithm is used to discover the actual execution process model from the trajectory set of the project execution process event log. The actual execution process model is represented in the form of a workflow net, which is formally defined as a quadruple. Where P represents the finite set of all libraries, and T represents the finite set of transitions. This represents the set of directed arcs connecting places and transitions. The initial identifier is indicated; the execution steps of the process discovery algorithm include: traversing each trajectory in the project execution process event log, counting the frequency of follow-up relationships between tasks, and constructing a task relationship matrix; identifying sequential, parallel, selection, and cyclic relationships between tasks based on the follow-up relationship frequency; constructing the place nodes and transition nodes of the workflow network based on the identified relationship types, and establishing corresponding flow relationships; performing structured verification on the constructed workflow network to ensure that the workflow network satisfies the reachability and boundedness of Petri nets.

7. The intelligent optimization scheduling and management method for the entire project process according to claim 6, characterized in that, The compliance check process for identifying execution deviations described in step 5 includes: The actual execution process model discovered is aligned and compared with the expected process model constructed based on the dependency matrix. The compliance check includes task execution order deviation detection and task duration deviation detection. The task execution order deviation detection is as follows: detect whether the task execution order in the event log trajectory of the project execution process violates the dependency constraints in the expected process model. For the detected deviation event, record the deviation type, the task identifier in which the deviation occurred, and the timestamp of the deviation occurrence. The deviation type includes task early execution deviation, task delayed completion deviation, task skipping deviation, and task repeated execution deviation. The task schedule deviation detection is as follows: for each task Calculate the project schedule deviation rate ,in The actual duration of the task. For the estimated project duration collected in step 1, when the project duration deviation rate... The absolute value exceeds the preset threshold At that time, determine the task There is a significant deviation in the project schedule.

8. The intelligent optimization scheduling and management method for the entire project process according to claim 7, characterized in that, Step 5, which describes the process of identifying bottlenecks in the performance analysis workflow, includes: Average waiting time for each transition calculation task in the actual execution process model Cumulative delay of the process path in which the task is located Intensity of competition with resources ; The average waiting time of the task The calculation method is as follows: ,in This indicates the number of times task t is executed. This represents the actual start time of the k-th execution of task t. This represents the planned start time of the k-th execution of task t; The cumulative delay The calculation method is as follows: ,in This represents the set of all tasks on the critical path from the start of the process to task t. This represents the delay of a single execution of task u; The intensity of resource competition The calculation method is as follows: ; Tasks that meet one of the following conditions are identified as process bottlenecks: the average waiting time of the task. Ranked first among all tasks The cumulative delay amount Ranked first among all tasks or the intensity of resource competition Exceeding the preset threshold , where K is a preset percentile threshold parameter.

9. The intelligent optimization scheduling and management method for the entire project process according to claim 8, characterized in that, Step 5, which involves generating adaptive scheduling adjustment instructions and updating the initial project full-process knowledge graph based on the analysis results, includes: Based on the execution deviation and the process bottleneck, an adaptive scheduling adjustment instruction is generated. The generation rules include: when a task execution deviation is detected that causes a resource conflict, a task start time postponement instruction is generated. The task start time postponement instruction includes a target task identifier and a postponed start time, and the postponement amount is the minimum time interval required to resolve the conflict; when a task completion delay deviation is detected and the schedule deviation rate is... Exceeding the preset threshold When the delay of the delayed task occurs, a start time postponement instruction is generated for all subsequent tasks affected by the delayed task, with the postponement amount equal to the delay amount of the preceding task. Resource allocation instructions are also generated for unstarted tasks on the process path where the delayed task is located. When a bottleneck task is identified, a bottleneck resolution instruction is generated, which includes a resource allocation instruction to allocate parallel execution resources to the bottleneck task and a process reorganization instruction to optimize the preceding dependencies of the bottleneck task. When the resource contention intensity... Exceeding the preset threshold At that time, a resource conflict resolution instruction is generated to adjust the priority order of multiple tasks competing for the same resource; The operation of updating the initial project's full-process knowledge graph includes: updating the actual task duration attribute of the task entity nodes in the knowledge graph to the actual task duration. Update the actual resource allocation attribute of the task to the actual resource identifier. Update the task duration deviation rate attribute to the duration deviation rate. Based on the discovered actual flow relationships between tasks in the actual execution process model, new actual flow relationship edges are added to the knowledge graph, connecting the task entity nodes that are sequentially executed in the actual execution order; identified process bottleneck tasks are marked as bottleneck task node types, and bottleneck type attributes and average waiting time attributes are added to the process bottleneck task entity nodes; the generated adaptive scheduling adjustment instructions are added to the knowledge graph as scheduling adjustment instruction entity nodes, and the scheduling adjustment instruction entity nodes are connected to the target task entity nodes through adjustment object relationship edges, and the scheduling adjustment instruction entity nodes are connected to the deviation event entity nodes or process bottleneck task entity nodes that trigger the adjustment through generation basis relationship edges; the version number of the knowledge graph is incremented to form a knowledge graph version record with a timestamp.

10. An intelligent optimization scheduling and management system for the entire project lifecycle, characterized in that, It includes a memory configured to store instructions, a processor configured to retrieve the instructions from the memory, and, when executing the instructions, to implement an intelligent optimization scheduling and management method for the entire project process as described in any one of claims 1-9.

Images