A supplier delivery risk assessment method based on a supply chain knowledge graph

Abstract

The application discloses a supplier delivery risk assessment method based on a supply chain knowledge graph, and particularly relates to the fields of supply chain management and delivery risk assessment, and comprises the following steps: acquiring order execution data; forming an occupied time period by pairing and processing start and end events by a resource side edge computing node; obtaining a resource code by one-way hashing of a splicing value of a purchase network version number and a local resource number, and forming resource capacity and occupation records according to an enabled processing unit; connecting processes according to an execution sequence, connecting different supplier processes to the same resource node according to the resource code, connecting logistics nodes along a transfer direction, and constructing a supply chain knowledge graph from a node after a completed process to a delivery node; performing anonymous consistent coding on actual occupation events of shared resources by the edge computing node, reconstructing cross-supplier resource dependency relationships based on the supply chain knowledge graph, and extracting a core conflict order set in combination with an inertia clause generation algorithm and a Karmos algorithm.

Description

Technical Field

[0001] This invention relates to the field of supply chain management and delivery risk assessment technology, and more specifically, to a supplier delivery risk assessment method based on supply chain knowledge graph. Background Technology

[0002] Existing supplier delivery risk assessments are mostly based on historical on-time delivery rates, order execution progress, inventory levels, capacity declaration information, and logistics status. They organize the relationships between suppliers, orders, materials, and upstream and downstream enterprises, and judge the risk of order delays accordingly. In multi-tiered supply scenarios such as automotive parts and electronic components, multiple Tier 1 suppliers may share the same heat treatment equipment, special molds, testing stations or shipping channels. However, due to commercial confidentiality and data ownership restrictions, each supplier usually only provides its own order progress and nominal capacity. The true identity, affiliated company and complete schedule of shared resources are difficult to disclose to the purchaser. At the same time, delivery risks need to be assessed before the order is substantially delayed. At this time, the capacity and schedule declared by each supplier may meet the delivery requirements, and the existing assessment results still show normal due to the lack of cross-supplier resource sharing relationship; when multiple orders occupy the same restricted resources in similar time periods, the site will experience phenomena such as increased waiting tasks, delayed planned start time, work-in-process inventory retention, and synchronous delays of related orders. Because supply chain knowledge graphs lack the basis for linking different supplier orders to the same actual resource without disclosing the true identity of the resource, existing methods struggle to identify implicit resource competition relationships between orders and determine the scope of orders that jointly trigger delivery risks. The technical problem this application aims to solve is: without disclosing the true identity and corporate affiliation of shared resources, based on the actual resource occupancy information obtained from edge nodes, to identify the implicit competitive relationship between multiple supplier orders for the same restricted resource in the supply chain knowledge graph, and to determine the core conflict order set that causes supplier delivery risks. Summary of the Invention

[0003] To overcome the aforementioned deficiencies of the prior art, embodiments of the present invention provide a supplier delivery risk assessment method based on a supply chain knowledge graph. This method uses edge computing nodes to anonymize and consistently encode actual occupancy events of shared resources, reconstructs cross-supplier resource dependencies based on the supply chain knowledge graph, and combines a lazy clause generation algorithm and a Kamous algorithm to extract a set of core conflicting orders, thereby solving the problems mentioned in the background art.

[0004] To achieve the above objectives, the present invention provides the following technical solution: a supplier delivery risk assessment method based on supply chain knowledge graph, comprising: S1. Obtain order execution data. The resource-side edge computing nodes are paired to process start and end events to form the occupied time period. The resource code is obtained by performing a one-way hash on the concatenation value of the procurement network version number and the local resource number. Resource capacity and occupied records are formed according to the enabled processing unit. S2. Connect the processes according to the execution order, connect the processes of different suppliers to the same resource node according to the resource code, connect the logistics nodes along the transfer direction, construct the supply chain knowledge graph, and read from the node after the completed process to the delivery node to obtain the remaining execution chain; S3. The task position is represented by the start time variable, the task scheduling is controlled by the order reservation variable, the upper bound of the start is obtained by subtracting the task duration from the delivery time in reverse, and the lower bound of the start is obtained by accumulating the duration of the preceding task in forward from the end of the occupied time period. The lazy clause generation algorithm is used to propagate the relationship between task order and resource capacity. S4. The upper bound of the start and the lower bound of the end form a mandatory interval. The resource timeline is divided according to the endpoints, and the task occupancy of the segment is accumulated. When the occupancy exceeds the resource capacity, the variable boundary and the order retention variable are encoded as conflict clauses and the process is jumped back to the second-highest decision level for propagation until the schedule has a solution or there is zero decision level conflict. S5. After a zero-decision-level conflict, the order retention variable is used as a soft clause, and the remaining execution chain and resource capacity relationship are used as hard clauses. The Kamous algorithm is used to call the lazy clause generation algorithm to enumerate the set of orders that cannot be deleted. The hit set enumeration is used to obtain the core conflict order set. The resource code, supplier and logistics node are traced back along the supply chain knowledge graph. The delivery risk result is generated according to the segmentation corresponding to the conflict clause.

[0005] In a preferred embodiment, S1 includes: S11. Obtain the processing events collected by the edge computing nodes on the resource side, merge the processing events according to the local resource number and the processing unit number, and then arrange them according to the event sequence number. For the same event sequence number, retain the processing event that was received earlier, and obtain the event chain of each processing unit. The local resource number refers to a unique number assigned by the resource manager in the local resource registration table to a single piece of equipment, a single set of molds, a single inspection station, a single loading station, or a single transportation channel. The same local resource number corresponds to only one actual resource during the validity period of the procurement network version. The processing unit number refers to the number of the work unit within the same actual resource that can independently execute order processing tasks. When a resource has only one work unit, the processing unit number takes a fixed value of one. When a resource contains multiple parallel work units, each processing unit is numbered separately. The resource side refers to the side that directly controls the actual operation of resources and can obtain data on the start of processing, the end of processing, the start and stop of processing units, and the rated processing volume. This includes the equipment control end, warehousing control end, detection control end, or transportation control end of the enterprise to which the resources belong. S12. Read the event chain sequentially. When reading the start event, save the order number and start time. When reading the first end event corresponding to the same order number, write the end time and clear the start event. Use the paired start time and end time to form the occupied time period. Unpaired events are left on the resource-side edge computing node to wait for subsequent processing events. The start event refers to the event record generated when the processing unit begins to occupy actual resources to execute the order task, and it carries at least the local resource number, processing unit number, order number, event sequence number and start time; the end event refers to the event record generated when the same processing unit completes or terminates the corresponding order task, and it carries at least the local resource number, processing unit number and order number that are the same as the start event, and also carries the end time. An order number is a unique identifier assigned by the procurement network to a single supplier delivery task. It is used to associate the corresponding process, logistics task, resource usage record, and delivery time of the order.

[0006] In a preferred embodiment, S1 further includes: S13. The procurement network version number is placed before the local resource number to form an encoding string. The resource-side edge computing node uses the procurement network key to perform a message authentication code operation based on SHA-256 on the encoding string. The fixed segment of the operation result is extracted to form a resource code. When the procurement network version number changes, a new resource code is generated according to the same rules, and the original resource code and the new resource code are connected at the time of version change. The procurement network version number refers to the version number generated when the scope of suppliers, resource coding rules, or data sharing scope in the procurement network changes. The same procurement network version number corresponds to a fixed set of resource code generation rules and procurement network keys. The procurement network key refers to the symmetric key generated by the procurement network management terminal and distributed to the edge computing nodes on the resource side. The same procurement network key is used within the same procurement network version, and different procurement network keys are used for different procurement network versions. The process of performing SHA-256-based message authentication code operation is as follows: First, the procurement network key is padded or compressed into a 64-byte key block. Then, a byte-by-byte XOR operation is performed with the 64-byte internal padding value 0x36 and the external padding value 0x5C respectively. The internal XOR result is concatenated with the encoded string and then SHA-256 operation is performed to obtain the internal digest. Finally, the external XOR result is concatenated with the internal digest and then SHA-256 operation is performed to obtain a 256-bit operation result. Fixed bit refers to the bit segment formed by extracting the first 128 bits from the first bit of the 256-bit operation result. Within the same procurement network version, resource codes are generated according to this extraction position and extraction length. S14. Divide the resource running time according to the boundary of the occupied time period and the start and stop time of the processing unit. In each segment, accumulate the rated processing capacity of the processing unit in the enabled state to form the resource capacity, and write the resource code, order number, occupied time period and corresponding resource capacity into the occupancy record. The process of segmenting the resource running time is as follows: extract the start time, end time, start time, and stop time of all occupied time periods, delete duplicate times, arrange them in chronological order, and take two adjacent times as a segment, so that the set of processing units participating in the processing in each segment remains unchanged. Rated processing capacity refers to the number of orders that a processing unit can complete within a unit of time according to the equipment registration parameters. For piece-rate resources, the number of pieces processed per unit of time is used; for weight-based resources, the weight processed per unit of time is used; and for transportation resources, the number of items carried per shift is used. The units of measurement must be consistent across all occupancy records corresponding to the same resource code.

[0007] In a preferred embodiment, S2 includes: S21. Obtain the process records and occupancy records of the supplier's order, merge the process records by order number, connect adjacent processes by process order to form process edges, and then connect the corresponding processes to the same resource node by resource code to obtain the order process diagram. The process record refers to the order processing record formed by the order number and process sequence as a joint identifier. It records the process number, processing resource code, input quantity, completion quantity, start time, end time and execution status of the corresponding process, and is used to determine the sequential relationship and completion position of each process in the order. Resource nodes are graph nodes that are uniquely identified by resource codes. They are used to aggregate process nodes that actually occupy the same production or logistics resources in different supplier orders, and to save the time period and amount of occupation of the corresponding process through resource occupation relationships. S22. Based on the dispatch node, arrival node and transshipment order in the logistics records, connect the output node of the previous process to the input node of the next process, and merge the corresponding logistics nodes when the same transportation task points to the same logistics resource to form a supply chain knowledge graph that connects process nodes, resource nodes and logistics nodes. The logistics record refers to the execution record formed when goods are transferred between two processing locations. The transfer is identified by the transportation task number and records the order number, dispatch node, arrival node, transfer order, logistics resource code, shipment volume, arrival volume, dispatch time and arrival time. The dispatch node is a graph node formed when the goods leave the previous processing location, and the arrival node is a graph node formed when the goods enter the next processing location. The two nodes are determined by the transport task number and the transfer location number, and the transport task number and the receiving location number, respectively. Within the same order, each transportation task is arranged in an integer order according to the direction of cargo flow. The first transportation task takes one, and when the dispatch node of the next transportation task takes over the arrival node of the previous transportation task, the order is increased by one based on the previous transportation task. Output nodes are graphical nodes that record the qualified output quantity and output location after the process is completed. Input nodes are graphical nodes that record the actual received quantity and receiving location before the next process begins. When the output node and the shipping node are in the same position, a transfer relationship is established. When the input node and the arrival node are in the same position, a receiving relationship is established. A transportation task refers to an execution task that transports a specified quantity of goods under the same order from one shipping node to one arrival node. It is uniquely identified by a transportation task number, and the order number, logistics resource code, and transshipment order remain unchanged until the task is completed. Logistics resources refer to a single operating vehicle or work location that actually undertakes transportation, loading or transshipment. The logistics resource side assigns a local resource number and generates a resource code according to S1, so that the same logistics resource within the same procurement network version corresponds to the same resource code. A logistics node is a graph node established using a transportation task number and a logistics resource code as a joint identifier. When multiple logistics records for the same transportation task point to the same logistics resource code, they are merged into the same logistics node. When different transportation tasks occupy the same logistics resource, logistics nodes are established separately and connected to the corresponding resource node. A process node is a graph node established using the order number and process sequence as a joint identifier. It is used to store the input quantity, completion quantity, execution status and resource code of the corresponding process, and to establish directed process edges with the previous process node and the next process node according to the process sequence. S23. Starting from the node after the last completed process, read along the process edge and logistics edge in the supply chain knowledge graph to the delivery node; when a process is split, allocate the pending quantity according to the actual outgoing quantity of each branch; when a process is merged, accumulate the pending quantity according to the actual arrival quantity of each preceding branch, and delete the branch with a pending quantity of zero, to obtain the remaining execution chain that retains the execution order and pending quantity. The logistics edge refers to the directed graph edge established according to the direction of cargo transfer, including the dispatch edge pointing from the output node to the logistics node and the arrival edge pointing from the logistics node to the input node. The edge stores the transfer order, dispatch volume and arrival volume of the corresponding transportation task. A delivery node refers to the final node on the diagram after a supplier's order has completed all processes and transportation tasks. It is determined by the order number and delivery batch number, and records the agreed delivery time, delivery location, and quantity to be delivered. The actual transfer quantity refers to the quantity of physical handover completed along a branch after the process is broken down. It is obtained by accumulating the quantity recorded in the transfer events of that branch and then deducting the quantity recorded in the handover cancellation events and return events. It uses the same unit of measurement as the order. The pending quantity refers to the quantity of goods that still need to be processed along the corresponding process branch or logistics branch after the current moment. For process nodes, it is obtained by subtracting the qualified quantity that has been completed and transferred from the actual input quantity. For logistics nodes, it is obtained by subtracting the quantity that has arrived and been handed over from the actual shipment quantity. When the calculation result is zero, the corresponding branch is deleted.

[0008] In a preferred embodiment, S3 includes: S31. Read the remaining execution chain and the occupied time period formed by edge computing nodes in the supply chain knowledge graph. Divide the task processing volume by the corresponding resource capacity to obtain the task duration. Read the task in reverse from the delivery node along the process edge and logistics edge. Write the time of the current task start upper bound as the time of the subsequent task start upper bound after deducting the current task duration and the transfer time. Then read the task in forward from the end of the occupied time period along the remaining execution chain. Write the time of the current task start lower bound as the time of the previous task start lower bound after adding the transfer time lower bound to the previous task lower bound. The upper start bound refers to the endpoint after the start time that a task is allowed to use without exceeding the delivery time, the duration of subsequent tasks, and the transit time. It is obtained by subtracting the current task duration and the transit time from the upper start bound of subsequent tasks in sequence. The lower end bound refers to the endpoint before the end time formed when the task is executed according to the lower start bound. It is obtained by adding the task duration to the lower start bound. The upper end bound in S32 is obtained by adding the task duration to the upper start bound and is used together with the lower start bound to limit the scope of task placement. The transit time refers to the time taken for goods to be transferred from the output position of the previous task to the input position of the next task. When there is a completion record on the logistics edge, the difference between the arrival time and the dispatch time is taken. When the logistics edge is not yet completed, the difference between the arrival time and the dispatch time recorded in the logistics plan is taken. When loading and unloading have been established as tasks, the transit time is no longer included. S32. Extract the lower start bound and upper end bound of the task boundary set and divide the resource time axis in chronological order. For each segment, calculate the task duration and deduct the required duration that can still be included before and after the segment. Multiply the required duration by the number of task units occupied and then accumulate it according to the resource code. When the accumulated result exceeds the product of the resource capacity and the segment duration, record the task boundary and order retention variable involved in the accumulation to form a capacity conflict item. The resource timeline refers to the scheduling time range of tasks corresponding to the same resource code. The starting point is the moment that is earlier in the lower bound of the associated task start time, and the ending point is the moment that is later in the upper bound of the associated task end time. The task start lower bound, start upper bound, end lower bound, end upper bound and the start and stop times of the processing unit are deduplicated and arranged in chronological order, with the interval between adjacent moments as the segment. The number of task-occupied units refers to the number of processing units locked simultaneously during task execution. When the rated processing capacity of each processing unit is consistent, the number of locked units is used directly. When the rated processing capacity of each processing unit is inconsistent, the baseline processing capacity in the resource registration table is used as a baseline unit. The rated processing capacity of each locked processing unit is divided by the baseline processing capacity and then summed to obtain the number of task-occupied units. The resource capacity in S32 is synchronously calculated using the baseline unit number obtained by converting the enabled processing units within the segment. The order reservation variable is a Boolean variable that corresponds one-to-one with a supplier order. When the value is 1, all unfinished tasks in the order are included in the current schedule. When the value is 0, all unfinished tasks in the order are removed from the current schedule. Tasks in the same order cannot be assigned different values. Changes in the value of the order reservation variable have a synchronous effect on the corresponding process tasks and logistics tasks.

[0009] In a preferred embodiment, S3 further includes: S33. Use the lazy clause generation algorithm to convert process edges and logistics edges into task priority clauses, convert order retention variables and corresponding task boundaries into task activation clauses, and convert task boundaries and order retention variables in capacity conflict items into conflict clauses. Then jump back to the level of the variable with the second-highest decision level in the conflict clause and tighten the task boundaries again according to the conflict clause. The lazy clause generation algorithm works as follows: First, the start time range of each task is encoded as boundary texts indicating that the start time is no later than a specified time and no earlier than a specified time. Order reservation variables are encoded as Boolean texts indicating that the order participates in the scheduling. Then, based on the process edge and logistics edge, the task sequence relationship is propagated. When the lower bound of the previous task's end plus the transit time is later than the lower bound of the subsequent task's start, the lower bound of the subsequent task's start is rewritten as the lower bound of the previous task's end plus the transit time, and the boundary text that caused this rewrite is saved. Next, the number of occupied units of the mandatory tasks is accumulated segment by segment according to the resource time axis. When the accumulated value exceeds the resource capacity, the order reservation variables and task boundary texts involved in the accumulation are combined into a conflict clause. If no conflict is formed, an undetermined boundary text is selected to establish a new decision layer according to the order of resource code, order number, task sequence, and boundary time. When a conflict is formed, the reason clauses saved during the boundary rewrite are used to eliminate the duplicate texts in the current decision layer one by one until the conflict clause retains only one text in the current decision layer. Then, the conflict clause is saved and the process is reversed. The decision level refers to the integer layer number from which the lazy clause generation algorithm records the source of variable values. The zero decision level stores the initial boundary of the task, the task duration, the task sequence relationship, and the resource capacity relationship. Each time an undetermined boundary text is selected for scheduling branching, the layer number is incremented by one. The boundary text obtained from propagation is recorded as the branch layer number that triggered this propagation. Each text in the conflict clause carries its own decision level. The process of re-tightening the task boundary based on the conflict clause is as follows: First, arrange the boundary texts in the conflict clauses from back to front according to the decision level. Then, backtrack to the second-ranked decision level and cancel the variable values ​​formed thereafter, so that the boundary text at the first decision level in the conflict clause becomes the only undetermined text. If the text indicates that the start time is no later than the specified time, rewrite the upper bound of the start time to the specified time. If the text indicates that the start time is no earlier than the specified time, rewrite the lower bound of the start time to the specified time. Then, based on the updated task boundary, repropagate the task priority relationship and resource capacity relationship until the task boundary no longer changes or a new conflict clause is formed. S34. Repeatedly execute task boundary propagation and capacity conflict term generation. When the task boundaries do not change and no new conflict clauses are generated in one round of propagation, output the scheduling boundary set. When a conflict clause is generated at the zero decision level, output the scheduling unsolvable result. This is used for supplier delivery risk analysis and logistics management of enterprise or organizational activities.

[0010] In a preferred embodiment, S4 includes: S41. Read the start upper bound and end lower bound of each task under the same resource code. When the start upper bound is earlier than the end lower bound, the two times form a mandatory interval. Then, arrange the endpoints of all mandatory intervals and the resource capacity change times in chronological order, and form segments with adjacent times. S42. For each segment, filter the tasks whose mandatory interval covers the segment and whose order retention variable is one, and sum the number of units occupied by the tasks to obtain the occupied amount; when the occupied amount exceeds the resource capacity within the segment, try deleting tasks in order of resource code, order number and task order. If the occupied amount still exceeds the resource capacity after the trial deletion, retain the deletion result; if the occupied amount does not exceed the resource capacity after the trial deletion, restore the corresponding task to obtain the set of non-deletable conflicting tasks.

[0011] In a preferred embodiment, S4 further includes: S43. Take the inverted text of the order retention variable of each task in the non-deletable conflict task set, the boundary text whose start time is later than the start of the segment, and the boundary text whose end time is earlier than the end of the segment to form a conflict clause. Arrange the assigned text in the conflict clause in descending order of the decision level number, cancel the assignment formed by the first decision level and roll back to the second decision level, and then update the corresponding task boundary with the unassigned text in the conflict clause. The reverse literal refers to the clause literal formed by performing a logical inversion on the current value of a Boolean variable; when the order retention variable is one, the corresponding reverse literal indicates that the order retention variable is zero, which is used to indicate that at least one associated order is removed from the current schedule when the conflict clause is true. Boundary text refers to Boolean text encoded by the size relationship between the variable at the start time of the task and the endpoint of the segment. Boundary text with a start time later than the start time of the segment indicates that the task starts after the start time of the segment, and boundary text with an end time earlier than the end time of the segment indicates that the task ends before the end time of the segment. The two boundary texts are used to negate the state that the task completely covers the segment. Assigned text refers to order-retained variable text or boundary text whose truth value has been determined in the current scheduling branch; text directly determined by branch selection is recorded in the corresponding decision level, and text determined by task sequence relationship, resource capacity relationship or generated clause deduction is recorded in the decision level that triggered the deduction; S44. Regenerate the required interval based on the updated task boundary and verify all segments of production resources and logistics resources. If the task boundary is not updated again and no conflict clause is generated in one round of verification, output the scheduling result. If all the text in the conflict clause comes from the zero decision layer, output the scheduling no solution result for supplier delivery risk analysis. Production resources refer to equipment, workstations, molds, or work locations that directly undertake order processing, assembly, testing, packaging, or warehousing tasks, and whose processing start and end events, processing unit start and stop status, and resource capacity are recorded by the resource-side edge computing nodes; each production resource uses the resource code generated by S1 as a unique identifier in the supply chain knowledge graph.

[0012] In a preferred embodiment, S5 includes: S51. Read the conflict clauses corresponding to the zero decision layer conflict, write each order's reserved variable as a soft clause that allows revocation, write the task sequence relationship, resource capacity relationship, and delivery time relationship generated by the remaining execution chain as an irrevocable hard clause, and connect each hard clause to the process edge, logistics edge, resource code, and segmentation segment that generate the corresponding hard clause in the supply chain knowledge graph to form a set of conflict clauses. S52. Using the Kamous algorithm, select a set of soft clauses and cancel them. Then, call the lazy clauses to generate a set of conflict clauses for algorithm verification. When there is a solution in the scheduling, restore the canceled soft clauses one by one in the order of order number. If there is still a solution after restoration, retain the restoration result. If there is no solution after restoration, cancel the corresponding soft clause again until restoring any remaining soft clause results in no solution in the scheduling. Obtain the set of orders that cannot be deleted and write the blocking clause that blocks the corresponding set of orders to be deleted and the set containing the corresponding set of orders to be deleted. Repeat the verification until there is no new set of orders to be deleted. The process using the Kamous algorithm is as follows: For each soft clause, an order retention variable is set. When the order retention variable takes the value 1, the corresponding soft clause participates in scheduling; when it takes the value 0, the corresponding soft clause is cancelled. Hard clauses always participate in scheduling. First, the lazy clause generation algorithm verifies the current value of the order retention variable. If there is a solution in the scheduling, the order retention variables with a value of 0 are read to form a candidate order deletion set. Then, the order retention variables in the candidate order deletion set are changed to 1 one by one according to the order number and re-verified. If there is still a solution in the scheduling, the rewritten result is retained; if there is no solution in the scheduling, the value is restored to 0. This continues until changing any order retention variable in the candidate order deletion set to 1 results in no solution in the scheduling, resulting in an unreducible order deletion set. Subsequently, disjunction blocking clauses are established for all order retention variables in the unreducible order deletion set, ensuring that subsequent values ​​retain at least one order. The corresponding order deletion set and the set containing the corresponding order deletion set are excluded. The process of candidate selection, item-by-item restoration, and blocking clause writing is repeated until, after adding all blocking clauses, there are no order retention variable values ​​that satisfy the hard clause.

[0013] In a preferred embodiment, S5 further includes: S53. Establish a covering table with the order deletion set as rows and the order retention variables as columns. Select the order retention variables one by one from the first uncovered order deletion set to form a search branch. After the branch covers all order deletion sets, delete the order retention variables in the branch one by one and re-verify the covering relationship. Then call the lazy clause to generate an algorithm to verify the conflict clause set corresponding to the retained orders, until deleting any order retention variable causes the order deletion set to be uncovered and the conflict clause set changes from unsolvable to solvable, thus obtaining the core conflict order set. S54. Following the connection relationship saved in S51, backtrack the core conflict order set to the commonly associated resource code and logistics node. From the end of the corresponding segment, accumulate the task duration and transit time along the remaining execution chain of each order to obtain the expected delivery time. Then, associate the orders with expected delivery times later than the actual delivery time with the corresponding suppliers to generate supplier delivery risk results.

[0014] The technical effects and advantages of this invention are as follows: 1. This solution generates a consistent resource code through edge computing nodes and writes it into the actual occupancy record. It can associate cross-supplier orders without disclosing the resource identity, thereby improving the ability to identify implicit resource competition. 2. By connecting processes, logistics nodes, and resource nodes based on the supply chain knowledge graph, the remaining execution chain of an order can be restored, providing a unified and traceable data foundation for shared resource conflict analysis; 3. By propagating the task time boundary in both forward and reverse directions and calculating the required workload of the segmentation, insufficient resource capacity can be detected in advance, reducing the risk of missed judgments caused by relying solely on declared capacity. 4. By using a lazy clause generation algorithm to convert capacity excess into conflict clauses, the task boundaries can be continuously tightened and the source of conflict can be located, reducing the interference of irrelevant orders on risk assessment; 5. The core conflict order set is extracted by using the Kamous algorithm and hit set enumeration, which can distinguish between necessary conflict orders and accompanying orders, making the scope of delivery risks and the responsible parties clearer. Attached Figure Description

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

[0016] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0017] Refer to the instruction manual appendix Figure 1 The present invention provides a supplier delivery risk assessment method based on supply chain knowledge graph, comprising: S1. Obtain order execution data. The resource-side edge computing nodes are paired to process start and end events to form the occupied time period. The resource code is obtained by performing a one-way hash on the concatenation value of the procurement network version number and the local resource number. Resource capacity and occupied records are formed according to the enabled processing unit. Supplier orders in the procurement network are executed by production equipment, testing stations, warehousing locations, and transportation vehicles, and related processing events are scattered across different resource control terminals. Only by unifying the event sequence, resource identity, and capacity definition can it be identified whether different supplier orders occupy the same actual resource. In this implementation, the order execution data for this round is frozen at the evaluation time. Processing events received after the evaluation time are included in the next evaluation version. All times are uniformly converted to the procurement network clock. The occupied time period adopts a half-open interval that includes the start time but does not include the end time. The resource-side edge computing node organizes the processing events, forms the occupied time period, generates resource codes, and calculates the time-sharing resource capacity accordingly. The specific processing process is as follows. After the order execution data enters the resource-side edge computing node, S11 first reads the processing events whose event time is no later than the evaluation time, and writes the resource-side domain number, resource internal sequence number, processing unit number, task instance number, order number, event type, event sequence number, event time, and receiving time for each processing event; The resource domain number is used to distinguish the resource manager, the resource internal sequence number is used to distinguish the actual resources controlled by the same manager, and the two are combined into a local resource number with a fixed field length. The processing unit number is used to distinguish the work units that independently execute tasks within the same actual resource. Events are grouped by local resource number and processing unit number, and then arranged by event sequence number and event time. When the event sequence number and other fields are the same, the record with the earlier reception time is retained. When the event sequence number is the same but the other fields are different, the record with the earlier reception time is retained and written into the event conflict record. When the event sequence number is missing, the sequence number space is retained. This generates a processing unit event chain carrying the evaluation version. After the event chain is sorted, the task occupancy relationship is established item by item according to S12: when reading the start event, an unclosed record is established with the local resource number, processing unit number and task instance number, and the order number and start time are written. When reading the end event or termination event of the same task instance number, write the event time as the end time and form an occupied time period from the start time to the end time; When an end event arrives first, it is temporarily stored, and the pairing is completed after the start event arrives; repeated end events will not generate occupied time periods; if an end event has not been obtained by the time of evaluation of the start event, the evaluation time is used as the temporary end time and written into the execution status; if a start event of a second task occurs in the same processing unit before the previous task has ended, the occupied status of the previous task is retained and written into the processing unit conflict record. The original events after pairing are retained in the event chain and marked as used, forming the order number, task instance number, processing unit number, occupied time period and occupied status for subsequent reading; When the true identity of a resource is stored at the resource control end, the resource code is generated according to S13: the edge computing node sequentially writes the byte length of the procurement network version number, the procurement network version number, the byte length of the local resource number, and the local resource number to form an unambiguous encoded string. Integers use a unified byte order, and characters use UTF-8 encoding. Then, HMAC-SHA-256 operation is performed using the procurement network key corresponding to the current procurement network version. The procurement network key is padded or compressed into a 64-byte key block, and XORed byte by byte with the 0x36 padding block and the 0x5C padding block respectively. First, SHA-256 operation is performed on the concatenation value of the inner XOR result and the encoded string, and then SHA-256 operation is performed on the concatenation value of the outer XOR result and the inner digest. The first 128 bits of the obtained result are extracted to form the resource code. When switching procurement network versions, tasks that started before the version took effect will use the original resource code until the task ends, while tasks that started after the version took effect will use the new resource code and be written into a resource code succession record consisting of the original resource code, the new resource code, and the time when the version took effect. When the procurement network discovers a conflict between a resource code and an existing anonymous resource registration, it returns a collision number. The edge computing node appends the collision number to the encoding string, recalculates, and registers the resource. After obtaining the resource code and the occupied time period, S14 extracts the start time, end time, start time and stop time of each occupied time period, deletes duplicate times and arranges them in chronological order, forming segments with adjacent times. When an event of termination, deactivation, start, or activation occurs at the same time, the processing unit that is terminated or deactivated is released first, and then the processing unit that is started or activated is added, so that the set of activated processing units in each segment remains unchanged. The rated processing capacity of each activated processing unit is accumulated using a unified unit of measurement to form the resource processing rate. The activated processing unit is converted into the resource unit capacity after being converted to the benchmark processing unit. Piece-based resources are calculated based on the number of pieces processed per unit time, heavy-weight resources are calculated based on the weight processed per unit time, and transportation resources are calculated based on the processing capacity per unit time obtained by dividing the transport volume of a shift by the shift duration. Processing units with missing rated processing capacity are not included in the resource processing rate and are marked with a capacity missing flag. When the start / stop status is missing and there is no prior confirmation status, it is processed as a stopped status. Finally, an occupation record is formed that includes resource code, order number, task instance number, occupation period, resource processing rate, resource unit capacity and evaluation version. The above process allows orders from different suppliers to still point to the same actual resource through the same resource code without disclosing the true identity of the resource. Taking the shared use of a heat treatment furnace by two component suppliers as an example, the edge computing node of the heat treatment center registers the furnace group as a local resource and registers the two furnace bodies as two processing units; the first order occupies the first furnace body from 8:00 to 10:00, the second order occupies the second furnace body from 9:00, and the second furnace body is deactivated at 11:00. The edge computing node divides the resource running time into 8:00, 9:00, 10:00 and 11:00, respectively forming the resource processing rate and resource unit capacity of the corresponding segment, and then writes the same resource code into the occupancy record of the two orders; The supply chain knowledge graph connects the relevant processes of two suppliers to the same resource node, providing a unified data foundation for subsequent identification of shared resource conflicts and supplier delivery risk assessment.

[0018] S2. Connect the processes according to the execution order, connect the processes of different suppliers to the same resource node according to the resource code, connect the logistics nodes along the transfer direction, construct the supply chain knowledge graph, and read from the node after the completed process to the delivery node to obtain the remaining execution chain; Order processes and logistics tasks are distributed across different records of suppliers, production resources, and transportation resources. The actual flow of goods from processing to delivery needs to be restored under the same evaluation version. This implementation method freezes process records, occupancy records, and logistics records at the evaluation time, and only reads records whose effective time is no later than the evaluation time and whose expiration time is later than the evaluation time. Data generated after the evaluation time is included in the next evaluation version. Then, order process relationships are established, logistics relationships are connected, and the remaining execution chain is extracted based on the cargo flow for task boundary calculation and reading. The specific processing process is as follows. The establishment of process relationships is based on the actual execution order of tasks within the order; after the resource-side edge computing node forms an occupation record, the processing S21 reads the process record and occupation record of the same evaluation version, merges the process records according to the order number, and then determines the process node by the order number and process order. When rework, re-inspection, or repeated processing occurs in the same process, a task instance number is added, and the rework task is established as the next process node to prevent the rework relationship from pointing back to the original process node and forming a cycle. Adjacent processes are connected as directed process edges according to their process order. Branch processes are connected to each subsequent process according to the process route. Merging processes retain all preceding process edges. When process order is repeated and the record content is consistent, the record with the earlier effective time is retained. When the record content is inconsistent, a process conflict record is written. When process order is missing, the connection of processes after the missing position is stopped. The occupancy record is linked to the corresponding process node according to the task instance number, and then linked to the resource node according to the valid resource code when the occupancy event occurred; When the procurement network version changes, the original resource code and the new resource code establish a connection edge through the resource code acceptance record. Each occupancy record is still connected to the resource code used when the event occurred, thus forming an order process diagram with the effective time, the expiration time and the evaluation version. When logistics activities are integrated into the order process diagram, process S22 first merges logistics records by order number and transportation task number, and determines logistics nodes by transportation task number, transportation segment number and logistics resource code; when the same transportation task involves vehicle change, transfer or reloading, the transportation segment number is added, and logistics nodes are established for each transportation segment. Duplicate records in the same transportation segment are merged according to event sequence number. The dispatch node is determined by the transport task number and the transfer location number, and the arrival node is determined by the transport task number and the receiving location number. When the output location of the previous process is consistent with the dispatch node, a dispatch edge is established. When the arrival node is consistent with the input location of the next process, an arrival edge is established. Each transport segment is then connected according to the transfer order. When a transshipment sequence is missing, the sequence is determined based on the consistency between the arrival position of the previous transport segment and the departure position of the next transport segment. If there are more than two successive relationships, a route conflict record is written and the connection of the relevant transport segments is stopped. Different logistics nodes under the same resource code are connected to the same resource node. Different transportation segments under the same transportation task are not merged. When the dispatch volume is greater than the arrival volume, the difference is written as the in-transit volume. When the arrival volume is greater than the dispatch volume, a logistics quantity conflict record is generated. After completing the above connections, the order process diagram is expanded into a supply chain knowledge graph that includes process nodes, logistics nodes, resource nodes, process edges, and logistics edges. When determining the scope of tasks that still need to be executed for an order, S23 starts reading from the node after the last completed task in each branch; when the order has not yet started execution, it starts reading from the first process node. When the process is partially completed, the original process node is retained, and the quantity to be processed is obtained by subtracting the qualified quantity that has been completed and transferred out from the input quantity. When there is no actual input quantity before the start of the process, the output quantity to be generated from the previous process is read to form the input quantity to be generated. The input quantity to be generated from the first process is the quantity to be delivered in the batch. When a process is split, first accumulate the actual output of each branch. When the accumulated amount equals the qualified output of the previous process, allocate the amount to be processed according to the actual output of each branch. When the accumulated amount is less than the qualified output, the difference is retained as the un-transferred amount of the previous process. When the accumulated amount is greater than the qualified output, stop reading the relevant branch and write the quantity conflict record. For branches that have not yet been actually transferred, read the amount to be transferred recorded in the process route. When processes converge, the batch process directly accumulates the actual arrival quantity of each branch. The assembly process deducts the arrival quantity of each branch according to the branch conversion coefficient recorded in the bill of materials, until the remaining quantity of any branch is less than one set. The number of sets that have been deducted is written as the quantity to be processed in the converged process. When multiple paths read the same task instance, only one task node is retained and the predecessor relationship is aggregated. Branches with zero pending processing volume no longer extend to the delivery node, and finally the remaining execution chain with task instance number, execution order, pending processing volume, resource code, transport segment number and evaluation version is obtained. Taking an automotive parts order as an example, after the stamping process completes 1,000 qualified parts, 600 parts enter the heat treatment branch and 400 parts enter the surface treatment branch. After the two branches are completed, they enter the assembly process together. The supply chain knowledge graph saves the two branches according to the actual outgoing quantity and deducts the actual arrival quantity of the two branches one by one according to the assembly bill of materials to form the quantity to be processed in the assembly process. When the heat treatment process in another supplier's order uses the same resource code, the two processes are connected to the same resource node, and the logistics transportation is connected to their respective delivery nodes according to the transportation segment number. The resulting residual execution chain simultaneously preserves the internal execution order of the order, cross-supplier resource relationships, and the flow of unfinished goods, providing a consistent data foundation for subsequent verification of shared resource capacity and supplier delivery risk analysis.

[0019] S3. The task position is represented by the start time variable, the task scheduling is controlled by the order reservation variable, the upper bound of the start is obtained by subtracting the task duration from the delivery time in reverse, and the lower bound of the start is obtained by accumulating the duration of the preceding task in forward from the end of the occupied time period. The lazy clause generation algorithm is used to propagate the relationship between task order and resource capacity. Once the remaining execution chain is determined, all unfinished tasks need to be converted into unified scheduling constraints. This implementation method freezes order, map, and resource data at the evaluation time, converts task volume, processing rate, resource capacity, and logistics time to the same procurement network clock, and adopts fixed time granularity and half-open time interval. During task execution, a predetermined processing unit is continuously occupied. Task instances are created for pause, line switching, vehicle switching, and batch processing. Based on this, the task scheduling range is determined through bidirectional boundary calculation, the essential workload within the resource time period is verified, and then the task boundary is adjusted and the scheduling result is judged using a lazy clause generation algorithm. The specific processing process is as follows. The task time boundary is calculated based on the processing time and execution relationship; when processing S31, the processing volume, number of occupied units, resource code and the relationship between the preceding and following tasks are read from the remaining execution chain; The task processing rate is the sum of the rated processing capacity of the processing units. The processing time is obtained by dividing the task processing capacity by the task processing rate. If the processing time is not divisible by the scheduling time granularity, it is rounded up and then the preparation time is added to form the task duration. When a logistics task is completed, the transit time is the difference between the actual arrival time and the departure time; when it is not yet completed, the time recorded in the logistics plan is used; loading and unloading are not counted again if they have been independently created as tasks. The reverse calculation starts from the delivery node. The upper bound of the current task's start time is obtained by subtracting the current task's duration and transit time from the upper bound of the subsequent task's start time. If there are multiple subsequent tasks, the one with the earlier time is taken. Forward calculation starts from the end time of the completed preceding task. If there is no completed preceding task, the time is taken as the latter of the order release time and the evaluation time. Then, the lower bound of the current task start is obtained by adding the transfer time to the lower bound of the end time of each preceding task. If there are multiple preceding tasks, the time is taken as the latter. The lower bound of the start and the task duration form the lower bound of the end; the upper bound of the start and the task duration form the upper bound of the end. When the lower bound of the start is later than the upper bound of the start, a boundary conflict term is generated. When the processing volume, processing rate, or transfer duration is missing, the calculation of the corresponding branch is stopped and the missing data status is recorded. Resource load verification is performed according to resource codes. When executing S32, the resource time axis starts with the time earlier in the lower bound of the associated task and ends with the time later in the upper bound. Then, the task boundary and resource capacity change times are sorted and segmented by adjacent times. For any task and segment, first calculate the time that the task can still be scheduled before and after the segment, then subtract the above time from the task time to obtain the mandatory time that cannot be moved out of the segment; if the calculation result is less than zero, it is recorded as zero, and if it exceeds the segment time, it is calculated according to the segment time. The required duration is multiplied by the number of units occupied by the task to form the required workload. Tasks with a value of one in the order retention variable are accumulated according to the resource code. The workload of segmented supply is obtained by multiplying the capacity of the resource unit of the segment by the segment length. When the cumulative required workload exceeds the supplied workload, save the relevant task boundaries, order reserved variables, resource codes and segments to form a capacity conflict item; When resource capacity changes, calculations are performed in segments based on the time of change. If the number of fixed processing units required by a task exceeds the capacity of any coverage period, it is not allowed to be scheduled across that period. Logical propagation is used to convert task relationships and capacity conflicts into computable constraints; when processing S33, a discrete start time variable is established for each task, and the start time not later than a specified time and not earlier than a specified time are encoded as boundary text; an order retention variable is established for each order, and its value uniformly applies to all unfinished tasks of that order; The process edge and logistics edge are converted into task sequence clauses. When the lower bound of the end of the preceding task plus the transfer time is later than the lower bound of the start of the subsequent task, the lower bound of the start of the subsequent task is updated, and the boundary text and graph edge relationship that caused the update are saved as the reason clause. Capacity conflict items are converted into conflict clauses, which are used to restrict at least one associated order from the current schedule, or at least one task from the conflict segment; When no conflict occurs, the undetermined boundary is selected and a decision layer is established according to the fixed order of resource code, order number, task priority and boundary time; when a conflict occurs, the duplicate text in the current decision layer is eliminated using the reason clause until only one text is retained. When conflict clauses involve multiple decision levels, the process reverts to the next highest decision level; when they involve only one non-zero decision level, the process reverts to the zero decision level; when all texts come from the zero decision level, the scheduling becomes unsolvable. After reverting, the corresponding task boundaries are tightened based on the remaining texts, and the task priority and resource capacity relationships are propagated again. The scheduling status is determined by repeated verification of finite boundary values; after entering S34, the task priority clause and task enable clause are propagated in each round, and then the task boundary, resource timeline and capacity conflict items are updated; when the boundary changes, propagation continues, and when a new conflict clause is generated, conflict analysis and bounce are performed; If multiple candidate start times still exist after the boundary stabilizes, the next decision layer is established in a predetermined order; the scheduling result is only output when all retained tasks have obtained a unique start time and the task order, resource capacity, and delivery time relationships have all been verified; if there are still undetermined variables, only the current boundary set is saved. Since each variable at the start time has a finite number of discrete values, and each branch and conflict clause excludes a set of values ​​that have been verified as failed, the final result is either a complete scheduling result or zero decision-level conflict; the former is written into the evaluation record of no shared resource scheduling conflict found, and the latter is handed over to S5 to extract the core conflict order set; Taking two supplier orders sharing the same heat treatment resource as an example, the first order has 120 units to be processed, occupying two processing units with a rated processing rate of 30 units per hour, and its task duration is two hours; the second order needs to be executed on the same resource for three hours. Calculate the lower and upper bounds of the start based on the completion and delivery times of their respective predecessors, and then verify the required workload of the two tasks in each segment. If the cumulative workload exceeds the resource supply workload, a capacity conflict item is generated, and the task boundary is adjusted through a lazy clause generation algorithm. After adjustment, the scheduling results can be output when resource occupancy is staggered, and when all boundary combinations cannot meet the capacity constraints, the scheduling result with no solution will be output, providing a basis for subsequent determination of core conflict orders.

[0020] S4. The upper bound of the start and the lower bound of the end form a mandatory interval. The resource timeline is divided according to the endpoints, and the task occupancy of the segment is accumulated. When the occupancy exceeds the resource capacity, the variable boundary and the order retention variable are encoded as conflict clauses and the process is jumped back to the second-highest decision level for propagation until the schedule has a solution or there is zero decision level conflict. The aforementioned task boundary set provides the time range within which each task can be scheduled into the resource timeline. S32 has verified the essential workload that tasks cannot be moved out within the scheduling window. Based on this, it is also necessary to identify tasks that completely cover all segments regardless of how the start time is adjusted, and to convert the reasons for resource overrun into conflict clauses that can drive boundary rollback. This implementation method uniformly adopts resource unit capacity verification for concurrent tasks. The occupied interval adopts a half-open interval that includes the start point but does not include the end point. Production resources and logistics resources are processed according to the same rules. The specific process is as follows. Resource conflict localization starts with fixed coverage relationships; when processing S41, tasks with a value of 1 are merged according to the resource code and the order retention variable is read. The start upper bound and end lower bound of each task are read. When the start upper bound is earlier than the end lower bound, the interval from the start upper bound to the end lower bound is recorded as a mandatory interval. If the two times are the same, a mandatory interval is not generated. Then, extract all the endpoints of the mandatory intervals and the time of resource unit capacity change under the same resource code, delete duplicate times and arrange them in chronological order, and form segments with adjacent times; when the task ends, the processing unit is deactivated, the task starts and the processing unit is activated at the same time, the resource units that are ended or deactivated are released first, and then the resource units that are started or activated are counted. If a task lacks a start upper bound or an end lower bound, it will not participate in the calculation of the required interval in this round, and will be written into the task boundary missing record for S3 to regenerate the task boundary. After entering the conflict task extraction stage, S42 filters tasks for each segment whose upper bound starts no later than the segment start point and whose lower bound ends no earlier than the segment end point, accumulates the number of units occupied by each task to obtain the occupied amount, and reads the resource unit capacity that remains unchanged within the segment. When the occupied amount exceeds the resource unit capacity, the order of trial deletion is determined according to the order number, task priority and task instance number. Each time, a task is temporarily deleted and the occupied amount is re-accumulated. If the occupied amount still exceeds the resource unit capacity after deletion, the deletion is retained. If the occupied amount no longer exceeds the resource unit capacity after deletion, the corresponding task is restored. This process continues until all tasks have completed one trial deletion. The resulting task set is recorded as the set of non-deletable conflicting tasks. The trial deletion state is only used to determine the source of the conflict. After the conflict is resolved, the original task set is restored. If there are other conflict combinations in the same segment, the subsequent scheduling branch will re-enter the segment and generate a new set of non-deletable conflict tasks. Once the set of non-deletable conflicting tasks is determined, the reasons for exceeding the capacity need to be written as logical constraints that can participate in lazy clause propagation. According to S43, first write the boundary text for each conflicting task whose start time is later than the start of the segment and whose end time is earlier than the end of the segment, and then write the reverse text of the corresponding order reserved variable; when the same order contains multiple conflicting tasks, retain the boundary text of each task and delete the duplicate reverse text of the order reserved variable according to the order number, thereby forming a conflict clause that indicates that at least one order is removed from the schedule or at least one task is removed from the segment. Conflict analysis eliminates duplicate texts at the same decision level by eliminating the reason clauses saved along each boundary text until only one text is retained at the current first decision level. If the conflict clause contains two or more different decision levels, it backtracks to the second highest decision level. If it contains only one non-zero decision level, it backtracks to the zero decision level. When all texts come from the zero decision level, a scheduling solution is formed. After the rollback is completed, if the unassigned text is the reverse text of the order reserved variable, the corresponding order reserved variable will be changed to zero. If the unassigned text indicates that the start time is later than the start of the segment, the lower bound of the start will be written as the first time granularity after the start of the segment. If the unassigned text indicates that the end time is earlier than the end of the segment, the upper bound of the end will be written as the first time granularity before the end of the segment, and the upper bound of the start will be updated by subtracting the task duration from the upper bound of the end. After completing a boundary update, S44 regenerates the start upper bound, start lower bound, end upper bound, and end lower bound of the relevant tasks, and verifies all segments of production resources and logistics resources along the resource code; Production resources include processing equipment, assembly stations, testing stations, packaging locations, and warehousing locations; logistics resources include vehicle shifts, loading locations, transfer locations, and transportation channels. Each resource uses the resource code and resource unit capacity generated by S1. If the task boundary changes or a new conflict clause is generated, continue propagation and backtracking; if the task boundary does not change and there are still multiple candidate times in the start time variable, return to S33 to establish the next decision layer; only when all retained tasks have obtained a unique start time and are verified by task sequence, resource unit capacity and delivery time will the scheduling result be output. When all the text of the conflict clause comes from the zero decision layer, the output is a scheduling unsolvable result, which is then handed over to S5 to extract the core conflict order set; Taking three supplier orders sharing a set of heat treatment furnaces as an example, the resource unit capacity from 10:00 to 11:00 is two. The upper limit of the start of each of the three heat treatment tasks is no later than 10:00 and the lower limit of the end is no earlier than 11:00. Each task occupies one resource unit, so the total occupancy is three. When deleting tasks sequentially by order number, the usage space is reduced to two after deleting any task, and the corresponding tasks are restored. The three tasks together form an unreducible set of conflicting tasks. Subsequently, a conflict clause is generated containing the reverse text of the three order retention variables and the boundary text of each task. If, after rollback, the lower bound of the start of one of the tasks can be moved to after 11:00, then the subsequent logistics tasks are rescheduled and verified; if all three tasks are restricted by the completion and delivery times of their predecessors and cannot be moved out of the segment, then a scheduling unsolvable result is formed at the zero decision level. Therefore, overcapacity can be accurately traced back to specific tasks, orders, resource codes, and segments, and provides verifiable conflict evidence for supplier delivery risk assessment.

[0021] S5. After the zero decision-making layer conflict, the order retention variable is used as a soft clause, and the remaining execution chain and resource capacity relationship are used as hard clauses. The Kamous algorithm is used to call the lazy clause to generate the algorithm enumeration of the non-deletable order deletion set. The hit set enumeration is executed to obtain the core conflict order set. The resource code, supplier and logistics node are traced back along the supply chain knowledge graph. The delivery risk result is generated according to the segmentation corresponding to the conflict clause. Zero decision-level conflict indicates that the supplier orders in the current evaluation version cannot simultaneously satisfy the relationships of task priority, resource capacity, and delivery time. It is also necessary to distinguish whether the conflict stems from resource competition between orders and to determine the order combination necessary to maintain the conflict. This implementation method first verifies the consistency of the fixed constraints themselves, then enumerates the set of orders that cannot be deleted using the Kamous algorithm, uses the covering relationship between the order deletion sets to reverse the core conflict order set, and finally restores the source of conflict along the supply chain knowledge graph to form the delivery risk result; the specific execution process is as follows; To eliminate false conflicts caused by graph relationship errors or abnormal resource data, the conflict clauses corresponding to zero decision layer conflicts are first read, and all order retention variables are set to zero in S51. Only the task sequence relationship, resource unit capacity relationship and delivery time relationship generated by the remaining execution chain are retained. The lazy clause generation algorithm is called to verify the fixed constraints. If fixed constraints still result in zero decision-level conflicts, the process edge, logistics edge, resource code, and segmentation that caused the conflict will be written into the data constraint conflict record, and the order conflict analysis will be stopped. When the fixed constraints have a solution, each order retains a variable to form a soft clause with a value of 1, while the task sequence relationship, resource unit capacity relationship, and delivery time relationship form a hard clause; Each hard clause simultaneously writes the evaluation version and source identifier, connects the task sequence relationship to the corresponding process edge or logistics edge, connects the resource unit capacity relationship to the resource code and segmentation segment, and connects the delivery time relationship to the delivery node, thereby generating a set of conflict clauses that can trace back the source of the graph from the logical constraints; The scope of order deletion is gradually narrowed through candidate generation, scheduling verification, and item-by-item restoration. When executing S52, a deletion variable is created for each order's retained variable. A value of 1 for the deletion variable indicates that the corresponding order's retained variable is zero. First, project the orders involved in the zero-decision-level conflict into a deletion request, so that at least one of the relevant orders is removed from the schedule. Then, the order selection layer generates a candidate order deletion set that satisfies all deletion requests and blocking clauses in ascending order of the number of deleted orders and order number order. If the scheduling still has no solution after the lazy clause generation algorithm verifies the candidate order deletion set, it extracts the order retention variable from the newly formed zero decision-level conflict and writes it into the new deletion requirement, and then generates the next candidate order deletion set. When there is a solution to the scheduling, delete orders are restored to participate in the scheduling one by one in order of order number. If there is still a solution after restoration, the corresponding order is removed from the candidate order deletion set. If there is no solution after restoration, the corresponding order is retained until the restoration of any remaining deleted order results in no solution to the scheduling, thus obtaining an order deletion set that cannot be deleted. Then, a blocking clause is written that requires at least one order in the order deletion set to participate in the subsequent scheduling, so as to exclude the order deletion set and the deletion combination containing the order deletion set, and the generation, verification and shrinking process is repeated; when there is no value in the order selection layer that satisfies all deletion requirements and the blocking clause, the enumeration stops and all non-deletable order deletion sets are output; After the set of all non-deletable orders is formed, the reverse lookup of conflicting orders is performed in S53; a covering table is built with the set of non-deletable orders as rows and the order retention variables as columns, and when an order belongs to the corresponding deletion set, a 1 is written at the intersection position; Starting from the first uncovered deletion set, orders are selected sequentially according to order number to form a search branch. Each time an order is selected, all deletion sets containing that order are covered, until all deletion sets are covered. Then, remove the orders in the search branch one by one and re-verify the coverage relationship. If the removal still covers the entire deleted set, retain the removal result. If the removal does not cover the deleted set, restore the corresponding order. This is how to obtain the non-deletable coverage set. When performing scheduling verification for each non-deletable coverage set, only the reserved variable for orders within the set is set to one, and the reserved variable for orders outside the set is set to zero. If orders within the set participate in scheduling simultaneously and generate zero decision-level conflicts, and scheduling results are obtained after setting each order within the set to zero one by one, then the set is determined as the core conflict order set. When the verification result is inconsistent with the coverage relationship, the new deletion request or order deletion combination generated by the verification is written back to S52 to continue enumeration; for each core conflict order set, the core blocking condition that excludes the set and the set containing the set is written, and the processing stops when there is no new search branch in the coverage table; The risk outcome is based on the logical conflict source and the remaining execution path of the order. According to S54, the process edge, logistics edge, resource code and segment involved in the core conflict order set are traced back one by one along the source identifier saved in S51, and the conflict source is merged by resource code and segment. When the same core conflict order set is associated with multiple production resources or logistics resources, conflict source records are generated separately, and it is not required that all orders are connected to a common logistics node. The estimated delivery time is calculated from the end of the corresponding conflict segment. The task duration and transfer time are accumulated in the forward direction along the remaining execution chain of the order. When the path is split, the completion time of each branch is calculated separately. When the path merges, the time of the completion time of each necessary preceding branch that is later is taken as the start time of the merging task. The merging task duration is then accumulated until the delivery node is reached. When the expected delivery time is later than the agreed delivery time, the corresponding order and supplier will be written into the delay risk record; when the expected delivery time is not later than the agreed delivery time but the core conflict order set is still unresolved, it will be written into the order group risk record, indicating that at least one order in the set cannot be completed on time at the same time as the other orders, so as to avoid classifying all orders in the set as delayed orders. Taking the example of three suppliers sharing the same testing station and the same transportation shift, when all orders are included in the scheduling, a zero-decision-level conflict is formed in the testing segment. Deleting the first order or simultaneously deleting the second and third orders can restore the scheduling, thus obtaining two non-deletable order deletion sets. After the covering table is reversed, two core conflict order sets are formed, and it is verified that there is no solution when both are retained, and there is a solution after deleting any one member. The supply chain knowledge graph further traces resource conflicts and transportation schedule conflicts back to the corresponding resource codes, segments, and logistics nodes. It then calculates the estimated delivery time along the remaining execution chain of each order, forming risk results pointing to suppliers, order combinations, and sources of conflict. This provides a verifiable basis for supplier delivery risk analysis and logistics management for enterprise or organizational activities.

[0022] Overall execution and implementation description: This solution first collects order processing events by edge computing nodes on the resource side to form resource occupancy periods, and generates resource codes and time-sharing resource capacity without disclosing the true identity of the resources; then, based on order processes, logistics tasks and resource codes, a supply chain knowledge graph is constructed to extract the unfinished processes and logistics paths of each order to form the remaining execution chain; This solution further calculates the start time range of tasks based on delivery time, task duration, and resource capacity, uses a lazy clause generation algorithm to propagate task priority and resource occupancy relationships, and generates conflict clauses when multiple orders cannot be scheduled into the same resource simultaneously. When the scheduling still has no solution at the zero decision level, the Kamus algorithm enumerates the order combinations that need to be deleted to restore the schedule, then obtains the core conflict order set through hit set calculation, and finally checks back the conflict resources, logistics nodes and affected time periods along the supply chain knowledge graph to form the supplier delivery risk result; For example, multiple auto parts suppliers may submit production schedules that meet delivery deadlines, but the relevant orders actually require the use of the same heat treatment furnace and the same transport schedule. The edge computing nodes at the locations of the heat treatment furnace and transport schedule record the actual occupancy of each order and hide the equipment and carrier information using resource codes. The supply chain knowledge graph identifies the common dependence of these orders on the same resource based on the same resource code. This solution schedules orders by combining the remaining processes, processing time, and delivery time. When it finds that the resource demand of some tasks exceeds the available capacity within the same time period, it generates conflict clauses. Then, it gradually eliminates orders that are not related to the conflict, identifies the order combinations that are truly causing the scheduling to be unsolvable, and calculates the expected delivery time of each order after subsequent processing and transportation, thereby pointing out the suppliers, orders, shared resources, and delivery risk periods involved.

[0023] The above description is merely a preferred embodiment of the present invention and is not intended to limit the present invention. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the protection scope of the present invention.

Claims

1. A supplier delivery risk assessment method based on supply chain knowledge graph, characterized in that, include: S1. Obtain order execution data. The resource-side edge computing nodes are paired to process start and end events to form the occupied time period. The resource code is obtained by performing a one-way hash on the concatenation value of the procurement network version number and the local resource number. Resource capacity and occupied records are formed according to the enabled processing unit. S2. Connect the processes according to the execution order, connect the processes of different suppliers to the same resource node according to the resource code, connect the logistics nodes along the transfer direction, construct the supply chain knowledge graph, and read from the node after the completed process to the delivery node to obtain the remaining execution chain; S3. The task position is represented by the start time variable, the task scheduling is controlled by the order reservation variable, the upper bound of the start is obtained by subtracting the task duration from the delivery time in reverse, and the lower bound of the start is obtained by accumulating the duration of the preceding task in forward from the end of the occupied time period. The lazy clause generation algorithm is used to propagate the relationship between task order and resource capacity. S4. The upper bound of the start and the lower bound of the end form a mandatory interval. The resource timeline is divided according to the endpoints, and the task occupancy of the covered segment is accumulated. When the usage exceeds the resource capacity, the variable boundary and order retention variables are encoded as conflict clauses, and the process is propagated back to the second-highest decision level until the schedule is resolved or there are zero decision-level conflicts. S5. After a zero-decision-level conflict, the order retention variable is used as a soft clause, and the remaining execution chain and resource capacity relationship are used as hard clauses. The Kamous algorithm is used to call the lazy clause generation algorithm to enumerate the set of orders that cannot be deleted. The hit set enumeration is used to obtain the core conflict order set. The resource code, supplier and logistics node are traced back along the supply chain knowledge graph. The delivery risk result is generated according to the segmentation corresponding to the conflict clause.

2. The supplier delivery risk assessment method based on supply chain knowledge graph as described in claim 1, characterized in that: S1 includes: S11. Obtain the processing events collected by the edge computing nodes on the resource side, merge the processing events according to the local resource number and the processing unit number, and then arrange them according to the event sequence number. For the same event sequence number, retain the processing event that was received earlier, and obtain the event chain of each processing unit. S12. Read the event chain sequentially. When reading the start event, save the order number and start time. When reading the first end event corresponding to the same order number, write the end time and clear the start event. Use the paired start time and end time to form an occupied time period. Unpaired events remain on the resource-side edge computing node to wait for subsequent processing events.

3. The supplier delivery risk assessment method based on supply chain knowledge graph as described in claim 2, characterized in that: S1 also includes: S13. The procurement network version number is placed before the local resource number to form an encoding string. The resource-side edge computing node uses the procurement network key to perform a message authentication code operation based on SHA-256 on the encoding string. The fixed segment of the operation result is extracted to form a resource code. When the procurement network version number changes, a new resource code is generated according to the same rules, and the original resource code and the new resource code are connected at the time of version change. S14. Divide the resource running time according to the boundary of the occupied time period and the start and stop time of the processing unit. In each segment, accumulate the rated processing capacity of the processing unit in the enabled state to form the resource capacity, and write the resource code, order number, occupied time period and corresponding resource capacity into the occupancy record.

4. The supplier delivery risk assessment method based on supply chain knowledge graph as described in claim 3, characterized in that: S2 includes: S21. Obtain the process records and occupancy records of the supplier's order, merge the process records by order number, connect adjacent processes by process order to form process edges, and then connect the corresponding processes to the same resource node by resource code to obtain the order process diagram. S22. Based on the dispatch node, arrival node and transshipment order in the logistics records, connect the output node of the previous process to the input node of the next process, and merge the corresponding logistics nodes when the same transportation task points to the same logistics resource to form a supply chain knowledge graph that connects process nodes, resource nodes and logistics nodes. S23. Starting from the node after the last completed process, read along the process edge and logistics edge in the supply chain knowledge graph to the delivery node; when a process is split, allocate the pending quantity according to the actual outgoing quantity of each branch; when a process is merged, accumulate the pending quantity according to the actual arrival quantity of each preceding branch, and delete the branch with a pending quantity of zero, to obtain the remaining execution chain that retains the execution order and pending quantity.

5. The supplier delivery risk assessment method based on supply chain knowledge graph according to claim 4, characterized in that: S3 includes: S31. Read the remaining execution chain and the occupied time period formed by edge computing nodes in the supply chain knowledge graph. Divide the task processing volume by the corresponding resource capacity to obtain the task duration. Read the task in reverse from the delivery node along the process edge and logistics edge. Write the time of the current task start upper bound as the time of the subsequent task start upper bound after deducting the current task duration and the transfer time. Then read the task in forward from the end of the occupied time period along the remaining execution chain. Write the time of the current task start lower bound as the time of the previous task start lower bound after adding the transfer time lower bound to the previous task lower bound. S32. Extract the lower start bound and upper end bound of the task boundary set and divide the resource time axis in chronological order. For each segment, calculate the required time after deducting the time that can still be included before and after the segment. Multiply the required time by the number of task units occupied and then accumulate it according to the resource code. When the accumulated result exceeds the product of the resource capacity and the segment duration, record the task boundary and order retention variable involved in the accumulation to form a capacity conflict item.

6. The supplier delivery risk assessment method based on supply chain knowledge graph according to claim 5, characterized in that: S3 also includes: S33. Use the lazy clause generation algorithm to convert process edges and logistics edges into task priority clauses, convert order retention variables and corresponding task boundaries into task activation clauses, and convert task boundaries and order retention variables in capacity conflict items into conflict clauses. Then jump back to the level of the variable with the second-highest decision level in the conflict clause and tighten the task boundaries again according to the conflict clause. S34. Repeatedly execute task boundary propagation and capacity conflict term generation. When the task boundaries do not change and no new conflict clauses are generated in one round of propagation, output the scheduling boundary set. When a conflict clause is generated at the zero decision level, output the scheduling solution result.

7. The supplier delivery risk assessment method based on supply chain knowledge graph as described in claim 6, characterized in that: S4 includes: S41. Read the start upper bound and end lower bound of each task under the same resource code. When the start upper bound is earlier than the end lower bound, the two times form a mandatory interval. Then, arrange the endpoints of all mandatory intervals and the resource capacity change times in chronological order, and form segments with adjacent times. S42. For each segment, filter the tasks whose mandatory interval covers the segment and whose order retention variable is one, and sum the number of units occupied by the tasks to obtain the occupied amount; when the occupied amount exceeds the resource capacity within the segment, try deleting tasks in order of resource code, order number and task order. If the occupied amount still exceeds the resource capacity after the trial deletion, retain the deletion result; if the occupied amount does not exceed the resource capacity after the trial deletion, restore the corresponding task to obtain the set of non-deletable conflicting tasks.

8. The supplier delivery risk assessment method based on supply chain knowledge graph according to claim 7, characterized in that: S4 also includes: S43. Take the inverted text of the order retention variable of each task in the non-deletable conflict task set, the boundary text whose start time is later than the start of the segment, and the boundary text whose end time is earlier than the end of the segment to form a conflict clause. Arrange the assigned text in the conflict clause in descending order of the decision level number, cancel the assignment formed by the first decision level and roll back to the second decision level, and then update the corresponding task boundary with the unassigned text in the conflict clause. S44. Regenerate the required interval based on the updated task boundary and verify all segments of production resources and logistics resources. If the task boundary is not updated again and no conflict clause is generated in one round of verification, output the scheduling result. If all the text in the conflict clause comes from the zero decision layer, output the scheduling result as unsolvable.

9. The supplier delivery risk assessment method based on supply chain knowledge graph as described in claim 8, characterized in that: S5 includes: S51. Read the conflict clauses corresponding to the zero decision layer conflict, write each order's reserved variable as a soft clause that allows revocation, write the task sequence relationship, resource capacity relationship, and delivery time relationship generated by the remaining execution chain as an irrevocable hard clause, and connect each hard clause to the process edge, logistics edge, resource code, and segmentation segment that generate the corresponding hard clause in the supply chain knowledge graph to form a set of conflict clauses. S52. Using the Kamous algorithm, select a set of soft clauses and cancel them. Then, call the lazy clause to generate a set of conflict clauses for algorithm verification. If there is a solution in the scheduling, restore the canceled soft clauses one by one in the order of order number. If there is still a solution after restoration, retain the restoration result. If there is no solution after restoration, cancel the corresponding soft clause again. Continue until restoring any remaining soft clause will result in no solution in the scheduling. Obtain the set of orders that cannot be deleted and write the blocking clause that blocks the corresponding set of order deletions and the set containing the corresponding set of order deletions. Repeat the verification until there is no new set of order deletions.

10. A supplier delivery risk assessment method based on supply chain knowledge graph as described in claim 9, characterized in that: S5 also includes: S53. Establish a covering table with the order deletion set as rows and the order retention variables as columns. Select the order retention variables one by one from the first uncovered order deletion set to form a search branch. After the branch covers all order deletion sets, delete the order retention variables in the branch one by one and re-verify the covering relationship. Then call the lazy clause to generate an algorithm to verify the conflict clause set corresponding to the retained orders, until deleting any order retention variable causes the order deletion set to be uncovered and the conflict clause set changes from unsolvable to solvable, thus obtaining the core conflict order set. S54. Following the connection relationship saved in S51, backtrack the core conflict order set to the commonly associated resource code and logistics node. From the end of the corresponding segment, accumulate the task duration and transit time along the remaining execution chain of each order to obtain the expected delivery time. Then, associate the orders with expected delivery times later than the actual delivery time with the corresponding suppliers to generate supplier delivery risk results.

Images