A real-time dynamic case packing optimization method and system for high hybrid SKU

Abstract

The application discloses a real-time dynamic packing optimization method and system for high hybrid SKU, relates to the technical field of logistics management, and comprises the following steps: acquiring a loading task and a current packing state; analyzing field-specific language business rules to generate executable constraint functions, graph construction metadata and arbitration metadata; constructing constraint dependency graphs, geometric graphs and heterogeneous state graphs; updating the heterogeneous state graph when an order is changed or a container is changed, and determining an influence domain based on logical association and geometric adjacency; inputting the updated heterogeneous state graph into a constraint-aware graph neural network to output a priority score and a position preference vector; generating an action set in the influence domain, pruning and locally re-optimizing to obtain an updated packing scheme. The scheme realizes rule structured expression, incremental solution of the influence domain and local rapid repair, reduces the dynamic rearrangement calculation amount and response time delay, and improves the packing compliance, stability and loading rate.

Description

Technical Field

[0001] This invention relates to the field of logistics management technology, and in particular to a real-time dynamic packing optimization method and a real-time dynamic packing optimization system for highly mixed SKUs. Background Technology

[0002] In cross-border e-commerce scenarios involving mixed orders and integrated warehousing and distribution fulfillment, packing optimization typically faces a complex environment with high SKU mix, strong business constraints, strong physical constraints, and frequent order disruptions. Loading tasks often need to output an executable 3D packing solution within a limited time, while simultaneously meeting business and safety constraints such as customer concentration, last-in-first-out (LIFO), hazardous materials isolation, fragile items protection, and heavy items at the bottom, while also considering loading efficiency and execution stability.

[0003] In existing technologies, common solutions include: First, packing software often employs heuristic stacking strategies with a few basic constraints, capable of handling packing and visualization on a general scale. However, under conditions of thousands of SKUs and complex business rules, it's difficult to balance solution quality and response speed, and it typically doesn't support dynamic order updates. Second, enterprise-developed systems often adopt a "rule engine + lightweight heuristic + manual review" approach, covering some business constraints, but still relying on manual intervention. Their responsiveness is insufficient when facing disruptive events such as temporary order additions, order deletions, and vehicle / container changes. Third, academic research or open-source models can achieve certain results on standard datasets, but due to the limited types of constraints, differences in data distribution, and insufficient engineering capabilities, they struggle to meet the multi-constraint and real-time requirements of industrial applications.

[0004] Furthermore, existing technologies generally suffer from the following technical problems in real-time packing of highly mixed SKUs: First, there is a lack of a unified, structured expression for "business rules - physical constraints - packing status," resulting in insufficient rule constraint processing capabilities, difficulty in simultaneously satisfying multiple types of constraints, and easy conflicts between rules leading to global inconsistencies. Second, the handling of order disturbances typically involves "starting from scratch" or large-scale rearrangement, making it difficult to achieve sub-second responses to dynamic events such as order additions, order deletions, and vehicle / container changes. Third, with thousands of SKUs, the candidate placement and search space grow explosively, and heuristic or locally rule-driven decisions are prone to getting trapped in local optima, making it difficult to balance loading rate, stability, and compliance.

[0005] Furthermore, even when existing technologies incorporate rule engines, graph structure representations, or graph neural networks, they typically only treat business rules as external verification conditions before solving or post-processing conditions after solving. They lack a mechanism to directly map the parsed business rules into edge types within the graph topology, making it difficult for the graph learning process to explicitly perceive and comply with business constraints. For heterogeneous constraints such as hazardous materials isolation, customer concentration, and load-bearing transmission, existing solutions often fail to differentiate between different constraint relationships during the graph message passing phase, easily leading to an inefficient cycle of generating solutions first and then verifying rules.

[0006] Furthermore, when dealing with dynamic reordering ranges, existing technologies typically only perform local searches based on geometric proximity or fixed-radius neighborhoods. Even if two SKUs are not spatially adjacent, if there is a strong business relationship between them, such as mandatory connection with pallets, mutual exclusion, or load-bearing dependence, traditional geometric neighborhood methods may still exclude them from the local reordering range. Conversely, for geometrically adjacent but logically unrelated SKUs, they are often included in the reordering process, leading to an expansion of the invalid search space and making it easy for local reordering to disrupt global business constraints.

[0007] Meanwhile, existing technologies typically lack a dynamic pruning mechanism for the influence domain based on the combined effects of logical topology and geometric distance. For local rearrangements triggered by dynamic events, if only a fixed volume threshold, a fixed search radius, or a simple voxel breadth-first traversal is used to expand the influence domain, it is difficult to adaptively adjust the search range according to the strength of business constraints. It is also impossible to effectively distinguish between two types of cases: those with strong logical dependencies but far apart geometrically and those with similar geometrically dependencies but no logical dependencies, making it difficult to balance real-time performance and solution quality. Summary of the Invention

[0008] To address the aforementioned problems, this invention provides a real-time dynamic bin packing optimization method and system for highly mixed SKUs. By parsing business rules described in a domain-specific language, executable constraint functions, graph construction metadata, and arbitration metadata are generated. Aggregation-type business rules, isolation-type business rules, and load-bearing or protection constraints are mapped as aggregation edges, conflict edges, and directed dependency edges, respectively. A constraint dependency graph is constructed by combining the SKU set, bin packing state, and graph construction metadata. A geometric graph is constructed by extracting geometric adjacency relationships between SKUs or virtual pallets based on a voxel mesh. Finally, the constraint dependency graph and the geometric graph are fused to generate a heterogeneous state graph, achieving a unified structured expression and consistent constraints for multiple types of business constraints, physical constraints, and spatial geometric states. Verification: By updating the heterogeneous state graph when orders or containers change, and obtaining the set of logically related nodes along the constraint dependency graph and the set of geometrically adjacent nodes along the voxel mesh from the changed node, the two are weighted and fused or the union is taken to determine the influence domain, avoiding global reordering and reducing update latency; by constructing a hierarchical action space within the influence domain, performing pruning, and using a constraint-aware graph neural network to perform feature aggregation for different edge types using message passing functions bound to edge types, including introducing suppression factors for conflicting edges and directional masks for directed dependency edges, the search efficiency and solution quality are improved; by backfilling the current packing scheme with the results of local re-optimization, real-time dynamic packing updates and improved compliance loading rates are achieved in high-mixed SKU scenarios.

[0009] To achieve the above objectives, this invention provides a real-time dynamic packing optimization method for highly mixed SKUs, comprising: Obtain a loading task, which includes container parameters, a set of SKUs to be loaded, and the current loading status. Each SKU in the SKU set is associated with dimensions, weight, and business attributes. The business rules described in a domain-specific language are parsed to generate executable constraint functions, graph construction metadata, and arbitration metadata. The graph construction metadata is used to map aggregation-type business rules to aggregation edges, isolation-type business rules to conflict edges, and load-bearing constraints or protection constraints to directed dependency edges, and records the edge direction, edge activation conditions, and edge weights. Based on the SKU set, the current packing status, and the graph construction metadata, a constraint dependency graph is constructed. Geometric adjacency relationships between SKUs or virtual pallets are extracted from the voxel mesh obtained by discretizing the three-dimensional space of the container to construct a geometric graph. The constraint dependency graph and the geometric graph are fused to generate a heterogeneous state graph. The nodes in the heterogeneous state graph represent SKUs or virtual pallets, and the edges include aggregated edges, conflicting edges, and directed dependency edges obtained by business rule mapping, as well as geometric association edges formed by the geometric adjacency relationships. Based on the arbitration metadata, conflicting business rules are resolved, and the current packing scheme is obtained under the constraints of the arbitration result. When an order change event or container change event is detected, the current packing status, the constraint dependency graph, and the geometry graph are updated and fused to generate an updated heterogeneous state graph. Starting from the change node associated with the change event, the set of logically associated nodes is obtained by traversing along the activated aggregation edges, conflict edges, and / or directed dependency edges in the constraint dependency graph. The set of geometrically adjacent nodes is obtained by traversing along the voxel grid. SKUs or virtual pallets that are not geometrically adjacent but have business constraint associations in the constraint dependency graph are included in the set of logically associated nodes. The set of logically associated nodes and the set of geometrically adjacent nodes are weighted and fused or the union is taken to determine the influence domain based on the result of the weighted fusion or union. The updated heterogeneous state graph corresponding to the influence domain is input into the constraint-aware graph neural network. The feature aggregation is performed by the message passing function bound to the edge type for different edge types. In this case, the neighbor information aggregation corresponding to the conflict edge is introduced with an inhibition factor, and the neighbor information aggregation corresponding to the directed dependency edge is introduced with a directional mask. The priority score and position preference vector of each SKU or virtual tray in the influence domain are output. Within the influence domain, an action set is generated based on the priority score and the position preference vector. Based on the executable constraint function, the arbitration result, the priority score, and the position preference vector, pruning and local re-optimization are performed on the action set. The local re-optimization result is then backfilled into the current bin packing scheme to obtain an updated bin packing scheme.

[0010] In the above technical solution, preferably, the parsing of business rules described in a domain-specific language generates executable constraint functions, graph construction metadata, and arbitration metadata, including: Based on abstract syntax tree-driven multi-product compilation, business rules are compiled into constraint functions for candidate placement verification, graph construction metadata for constructing the constraint dependency graph, and arbitration metadata for conflict resolution. The graph construction metadata includes rule identifier, rule category, edge type, edge direction, edge activation condition, and edge weight. The rule category includes at least aggregation business rules, isolation business rules, and load-bearing constraints or protection constraints. The edge type includes at least aggregation edges, conflict edges, and directed dependency edges. The graph builder generates corresponding edges between SKUs or virtual trays that meet the rule conditions based on the edge activation conditions. The arbitration metadata includes the static priority of rules and the default arbitration strategy for conflicting rule pairs. The executable constraint function is called for candidate placement verification. The graph construction metadata is called for constraint dependency graph construction. The arbitration metadata is called for conflict resolution.

[0011] In the above technical solution, preferably, the specific process of resolving conflicts in business rules includes: The initial arbitration result is determined based on the static priority of the rules and the default arbitration strategy of the conflicting rule pairs; After detecting an order change event or container change event, a conflict cost function is constructed based on the updated current loading status, the constraint check results of the executable constraint function, and the priority score and position preference vector output by the constraint-aware graph neural network. The conflict cost function comprehensively represents the priority of the conflict rule, the degree of violation of the current loading status, and the expected loss of the overall loading rate due to adjusting the corresponding rule. Based on minimizing the conflict cost function and in accordance with the default arbitration strategy, the low-priority rules in the conflict rule pair are downgraded or temporarily deactivated to generate runtime arbitration results. Record the rule conflict triggering conditions, conflict rule identifier, applicable default arbitration strategy, static priority, runtime arbitration result and the constraint check result corresponding to the runtime arbitration result, as well as the cost value corresponding to the conflict cost function, to form a decision log.

[0012] In the above technical solution, preferably, the constraint-aware graph neural network configures independent relation transformation parameters for aggregation edges, conflict edges, and directed dependency edges, and performs specific message passing according to edge type, specifically including: For the aggregation of neighbor information corresponding to the aggregation edge, a positive enhancement weight is adopted to enhance the tendency of SKUs or virtual trays that meet the aggregation business rules to be placed close to each other or in the same area. An inhibition factor is introduced for the aggregation of neighbor information corresponding to conflict edges to reduce the weight of conflict node features in the aggregation result; A directional mask is introduced for the aggregation of neighbor information corresponding to directed dependent edges. The constraint features are propagated only along the edge direction of the directed dependent edge, and the propagation of messages in the opposite direction to the edge direction is masked.

[0013] In the above technical solution, preferably, determining the influence domain based on the logically associated node set and the geometrically adjacent node set includes: Logical weights are determined based on edge type, edge weight, and path length in the path from the changed node to the candidate node in the constraint dependency graph, and logical-geometric coupling degree between the changed node and the candidate node is calculated based on the geometric distance between the changed node and the candidate node in the voxel mesh. When the candidate node is geometrically adjacent to the changed node and the logical-geometric coupling degree meets the basic threshold, the corresponding candidate node is included in the set of geometrically adjacent candidate nodes; or, when the candidate node is not geometrically adjacent to the changed node but the logical weight reaches the preset logical inclusion threshold, the corresponding candidate node is included in the set of logically associated candidate nodes. If a node with a logical weight higher than the preset high weight threshold is found within the current search radius, the search radius is expanded. If, during the traversal, candidate nodes with a logical-geometric coupling degree lower than the preset pruning threshold appear consecutively and the current accumulated logical weight has not reached the critical threshold, the traversal of the corresponding branch is terminated. A weighted fusion or union is performed on the set of geometrically adjacent candidate nodes and the set of logically related candidate nodes, and the final influence domain is determined based on the result of the weighted fusion or union.

[0014] In the above technical solution, preferably, the step of generating an action set within the influence domain and performing pruning and local re-optimization on the action set includes: Generate a set of actions that include the selection of the loading unit to be placed, the selection of the placement orientation, and the selection of the placement coordinates; The search order of the loading units to be placed is determined based on the priority score, and the search range of the candidate placement coordinates is limited based on the position preference vector; Maintain the multi-scale void index of the voids inside the container, and pre-compute the set of the largest void cuboids; Based on the multi-scale gap index and the set of largest gap cuboids, the action set is geometrically pre-screened to eliminate actions that cannot accommodate the loading unit to be placed. For candidate actions retained after geometric pre-screening, the verification order of placement orientation is determined according to a preset orientation priority rule, and temporary placement simulation and constraint check are performed on each placement orientation verified in the verification order. If the constraint check fails, the occupation state generated by the temporary placement simulation is cancelled. For candidate actions that pass the constraint check, local re-optimization candidate actions are determined by combining the arbitration result, the priority score, and the position preference vector, and target actions are selected from them and backfilled into the current packing scheme.

[0015] In the above technical solution, preferably, the nodes in the heterogeneous state graph include virtual trays, and the generation of the virtual trays includes: Based on the SKU's volume, aspect ratio, and business attributes, perform hybrid clustering on the SKU set to generate a virtual tray set; Based on the aggregation edges in the constraint dependency graph, the same virtual tray merging constraint is applied to SKUs that satisfy the aggregation business rules, and the conflict between the aggregation rules and the isolation rules is identified based on the conflict edges in the constraint dependency graph. SKUs that trigger the conflict are assigned to independent dedicated virtual trays. In the discrete space representation, the member SKUs of each virtual tray are pre-arranged internally to determine the minimum circumscribed cuboid, thereby determining the size of the circumscribed cuboid of the virtual tray. Based on the weight, business attributes and circumscribed cuboid size of the member SKUs, the aggregation features of the corresponding virtual tray nodes are generated, and the virtual tray nodes and their aggregation features are written into the heterogeneous state diagram. Under the constraints of the arbitration result, a pallet-level packing scheme is generated in the container using the virtual pallet as the loading unit. When the pallet-level packing fails or the loading rate of the pallet-level packing scheme is lower than a preset threshold, the clustering parameters used for the hybrid clustering are adjusted, and the virtual pallet set generation, internal pre-arrangement, and pallet-level packing are re-executed. After obtaining a pallet-level packing scheme that meets the preset threshold, the member SKUs in each virtual pallet are refined and arranged to generate the current packing scheme.

[0016] This invention also proposes a real-time dynamic packing optimization system for highly mixed SKUs, comprising: The data access module is used to acquire loading tasks and output container parameters, the set of SKUs to be loaded, and the current loading status; The rule compilation module is used to parse business rules described in a domain-specific language and generate executable constraint functions, graph construction metadata, and arbitration metadata. The rule arbitration module is used to resolve conflicts between conflicting business rules based on the arbitration metadata and output the arbitration result. The graph construction module is used to construct a constraint dependency graph based on the SKU set, the current packing status, and the graph construction metadata; generate virtual pallet nodes and their aggregation features based on the volume, aspect ratio, and business attributes of the SKUs and in combination with the aggregation edges and conflict edges in the constraint dependency graph; construct a geometric graph by extracting the geometric adjacency relationships between SKUs or virtual pallets from the voxel mesh obtained by discretizing the container's three-dimensional space; and fuse the constraint dependency graph, the geometric graph, and the virtual pallet nodes to generate a heterogeneous state graph, wherein the edges in the heterogeneous state graph include aggregation edges, conflict edges, directed dependency edges, and geometric association edges. The influence domain analysis module is used to update the current packing status, the constraint dependency graph, the geometry graph, and the heterogeneous state graph when an order change event or container change event is triggered. It obtains a set of logically related nodes based on the topological connectivity of the constraint dependency graph and a set of geometrically adjacent nodes based on the geometric adjacency of the voxel mesh. It also includes SKUs or virtual pallets that are not geometrically adjacent but have business constraint relationships in the constraint dependency graph into the set of logically related nodes. It performs a weighted fusion or union on the set of logically related nodes and the set of geometrically adjacent nodes, and determines the final influence domain based on the result of the weighted fusion or union. The graph neural reasoning module is used to input the updated heterogeneous state graph corresponding to the influence domain into the constraint-aware graph neural network, and to perform feature aggregation for aggregated edges, conflicting edges and directed dependent edges using a message passing method bound to the edge type, and output priority scores and position preference vectors. The action pruning and local re-optimization module is used to generate an action set within the influence domain, and perform pruning and local re-optimization on the action set based on the executable constraint function, the arbitration result, the priority score, and the position preference vector, and backfill the target action obtained from the local re-optimization into the current packing scheme; The solution output module is used to update the current packing scheme based on the local re-optimization results and output the updated packing scheme.

[0017] In the above technical solution, preferably, the graph neural reasoning module adopts a multi-relation graph convolutional structure, configures different relation transformation parameters for different edge types, and performs specific message passing for aggregation edges, conflict edges, and directed dependency edges respectively. Specifically, positive enhancement weights are used for the aggregation of neighbor information corresponding to aggregation edges, an inhibition factor is introduced for the aggregation of neighbor information corresponding to conflict edges, a directional mask is introduced for the aggregation of neighbor information corresponding to directed dependency edges, and message propagation opposite to the edge direction of the directed dependency edge is shielded. The output of the graph neural reasoning module includes a priority score and a position preference vector corresponding to the loading unit; The action pruning and local re-optimization module determines the search order of the action set based on the priority score, limits the search range of candidate placement coordinates based on the position preference vector, and sorts the candidate actions that pass the constraint check by combining the priority score and the position preference vector to select the target action.

[0018] In the above technical solution, preferably, it also includes a spatial index module, which is used to establish a voxel grid and a spatial hash index, and extract the geometric adjacency relationship between SKUs or virtual trays based on the voxel grid; The influence domain analysis module is used to determine the logical weight of the path based on the edge type, edge weight, and path length in the path from the changed node to the candidate node in the constraint dependency graph, and to calculate the logical-geometric coupling degree based on the geometric distance between the changed node and the candidate node in the voxel grid. When the candidate node and the changed node are geometrically adjacent and the logical-geometric coupling degree meets the basic threshold, the corresponding candidate node is included in the set of geometrically adjacent candidate nodes, or when the candidate node and the changed node are not geometrically adjacent but the logical weight of the path reaches the preset logical inclusion threshold, the corresponding candidate node is included in the set of logically associated candidate nodes. The module performs influence domain expansion and branch termination control based on the basic threshold, high weight threshold, pruning threshold, and key threshold, and performs weighted fusion or union on the set of geometrically adjacent candidate nodes and the set of logically associated candidate nodes to determine the final influence domain based on the result of the weighted fusion or union.

[0019] Compared with the prior art, the beneficial effects of the present invention are as follows: (1) By parsing business rules described in domain-specific languages, executable constraint functions, graph construction metadata and arbitration metadata are generated. Aggregation business rules, isolation business rules and load-bearing constraints or protection constraints are mapped to aggregation edges, conflict edges and directed dependency edges, respectively. This realizes the direct transformation of business rules into graph topology, so that business constraints no longer exist only as external verification conditions, but directly become the structured constraint basis in the bin packing solution process, thereby improving the consistency of constraint expression and the determinism of rule governance in multi-rule superposition scenarios.

[0020] (2) By constructing a constraint dependency graph based on the SKU set, the current packing status and the graph construction metadata, and extracting the geometric adjacency relationship between SKUs or virtual pallets based on the voxel mesh to construct a geometric graph, the constraint dependency graph and the geometric graph are then merged to generate a heterogeneous state graph, realizing the unified expression of business logic relationship and spatial geometric relationship. This enables the packing status to not only reflect rule dependency, but also reflect the geometric adjacency relationship between loading units, thereby improving the completeness and computability of the packing status expression under complex constraint environment.

[0021] (3) When an order change event or container change event is triggered, the set of logically related nodes is obtained along the constraint dependency graph, and the set of geometrically adjacent nodes is obtained along the voxel grid. The two sets are weighted and fused or the union is taken to determine the influence domain. This realizes the determination of the local reordering range driven by both logical topology and geometric adjacency. This allows loading units that are not geometrically adjacent but are strongly related in business to be included in the incremental solution range. At the same time, it avoids excessively involving loading units that are only geometrically close but logically unrelated in the reordering, thereby reducing the dynamic update computation and shortening the disturbance response delay.

[0022] (4) By inputting the updated heterogeneous state graph corresponding to the influence domain into the constraint-aware graph neural network, and using message passing functions bound to edge types for feature aggregation for different edge types, an inhibition factor is introduced for the aggregation of neighbor information corresponding to conflict edges, and a directional mask is introduced for the aggregation of neighbor information corresponding to directed dependent edges. This realizes the differentiated perception and processing of different constraint relationships in the graph reasoning process, so that the candidate action score can simultaneously reflect different constraint relationships such as aggregation, isolation and dependency, thereby improving the pertinence of candidate action evaluation and the rule compliance of the solution results.

[0023] (5) By generating an action set based on priority score and position preference vector within the influence domain, and performing pruning and local re-optimization on the action set based on executable constraint function, arbitration result, priority score and position preference vector, and backfilling the local re-optimization result into the current bin packing scheme, efficient local repair and continuous update under dynamic disturbance conditions are achieved. This reduces invalid action search and global recalculation, and improves the loading rate, stability and real-time update capability of the bin packing scheme. Attached Figure Description

[0024] Figure 1 This is a flowchart illustrating a real-time dynamic packing optimization method for highly mixed SKUs disclosed in one embodiment of the present invention. Detailed Implementation

[0025] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, 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, 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.

[0026] The present invention will now be described in further detail with reference to the accompanying drawings: like Figure 1 As shown, a real-time dynamic packing optimization method for highly mixed SKUs provided by the present invention includes: Obtain loading tasks, which include at least container parameters such as the container's internal dimensions, available loading space boundaries, and maximum load capacity, as well as the set of SKUs to be loaded and the current loading status. Each SKU records its physical dimensions (length, width, height), weight, and business attributes such as customer, order, category, hazard label, fragile label, and promotional label. For example: [Physical attributes: length, width, height, weight, fragile label, hazard class, UN code; Business attributes: customer ID, order ID, promotion ID, channel, inbound batch, time requirement; Status attributes: current location coordinates, current orientation].

[0027] The system parses business rules described in a domain-specific language, generating executable constraint functions, graph construction metadata, and arbitration metadata. The graph construction metadata maps aggregation-type business rules to aggregation edges, isolation-type business rules to conflict edges, and load-bearing or protection constraints to directed dependency edges, recording edge direction, activation conditions, and weights. The arbitration metadata characterizes the static priority of rules and the default arbitration strategy for conflicting rule pairs. Simultaneously, based on the arbitration metadata, conflict-ridden business rules are resolved, resulting in an arbitration outcome, ensuring that subsequent solutions are always performed under a consistent rule framework.

[0028] After obtaining the graph construction metadata, a constraint dependency graph is constructed based on the SKU set, the current loading status of the container, and the graph construction metadata. Then, geometric adjacency relationships between SKUs or virtual pallets are extracted from the voxel mesh obtained by discretizing the container's 3D space to construct a geometric graph. Finally, the constraint dependency graph and the geometric graph are merged to generate a heterogeneous state graph. In this heterogeneous state graph, nodes represent SKUs or virtual pallets, and edges include aggregated edges, conflicting edges, and directed dependency edges mapped from business rules, as well as geometric association edges formed by geometric adjacency relationships. Thus, business rules no longer exist merely as external validation conditions but are directly transformed into part of the graph topology, enabling business logic relationships and spatial geometric relationships to be expressed within a unified graph structure.

[0029] The current packing plan is generated under the constraints of the arbitration result and the executable constraint function. The packing plan includes the placement coordinates and orientation of each SKU in the container. For highly mixed order scenarios (e.g., thousands of SKUs and more than twenty constraint rules), the constraints are injected into the solution logic through rule executability and heterogeneous state graphs. The graph neural network inference results and local re-optimization are used as decision support to output an executable plan within the target time limit.

[0030] When an order change event or container change event (such as adding an order, deleting an order, or changing container parameters) is detected, the SKU set or container parameters are first updated based on the change event, and the current loading status of the container is updated synchronously. On this basis, the constraint dependency graph and the geometric graph are updated and merged to generate an updated heterogeneous state graph. Subsequently, starting from the change node associated with the change event, the set of logically associated nodes is obtained by traversing along the activated aggregation edge, conflict edge, and / or directed dependency edge in the constraint dependency graph. The set of geometrically adjacent nodes is obtained by traversing along the voxel grid. SKUs or virtual pallets that are not geometrically adjacent but have business constraint associations in the constraint dependency graph are included in the set of logically associated nodes. The set of logically associated nodes and the set of geometrically adjacent nodes are weighted and merged or the union is taken. The result of the weighted fusion or union is used to determine the influence domain. The influence domain corresponds to the subset of SKUs and spatial subdomains that need to participate in the incremental solution, so that the subsequent solution is transformed from global to local.

[0031] Within the influence domain, an action set is generated based on priority scores and position preference vectors. The action set includes the selection of the SKU to be placed, the selection of the placement orientation, and the selection of the placement coordinates. Based on the constraint dependency graph, executable constraint functions, and arbitration results, the action set is pruned to obtain a pruned action set. Obviously infeasible candidate actions are eliminated in advance, reducing the proportion of invalid searches.

[0032] The updated heterogeneous state graph corresponding to the influence domain is input into a constraint-aware graph neural network. Feature aggregation is performed using message passing functions bound to different edge types. Specifically, a suppression factor is introduced for the aggregation of neighbor information corresponding to conflicting edges to reduce the weight of conflicting node features in the aggregation result. A directional mask is introduced for the aggregation of neighbor information corresponding to directed dependent edges, propagating constraint features only along the edge direction of the directed dependent edges. The output is the priority score and position preference vector for each SKU or virtual tray within the influence domain. The priority score characterizes the search priority of the loading unit to be placed, and the position preference vector characterizes the preferred direction or preferred region of the candidate placement coordinates.

[0033] Based on the priority score and position preference vector, combined with the executable constraint function, as well as the arbitration result, priority score, and position preference vector, a local re-optimization is performed within the influence domain. The results of the local re-optimization are then backfilled into the current packing scheme to obtain an updated packing scheme. This ensures that the scope of the changes is related to the event size / local gap size rather than linearly related to the total number of SKUs in the entire pack.

[0034] In this implementation, a heterogeneous state graph is formed by fusing rule parsing and edge type mapping, constraint dependency graph and geometric graph, and influence domain is jointly determined by logical association and geometric adjacency. The closed-loop logic of graph neural reasoning and local re-optimization backfilling based on edge type binding message passing is used to generate executable packing schemes under thousands of SKUs and multiple constraints. Local incremental updates are also achieved when order disturbances or box changes occur, reducing dynamic response latency and improving scheme compliance and loading rate.

[0035] In the above implementation, preferably, the business rules described in a domain-specific language are compiled. The business rules in the domain-specific language are input by the operators in an IF-THEN structure similar to natural language. The compiler front end performs lexical and syntactic analysis to form an abstract syntax tree (AST), which is used to extract structured elements such as rule conditions, actions and priorities, thereby providing a unified semantic carrier for the back end to generate multiple types of compilation products.

[0036] The compiler backend outputs at least three types of results. First, it generates constraint functions for candidate placement verification. These constraint functions are injected into the solver's constraint checking loop and are called every time a SKU is attempted to be placed at a certain coordinate and orientation, thus putting the business rules into executable decisions.

[0037] Secondly, it generates graph construction metadata, which records information such as rule identifier, rule category, edge type, edge direction, edge activation condition, and edge weight in JSON or configuration table format. The rule category includes at least aggregation business rules, isolation business rules, and load-bearing or protection constraints, and the edge type includes at least aggregation edges, conflict edges, and directed dependency edges. The graph builder can generate corresponding edges and directions between SKUs or virtual trays that meet the rule conditions based on the rule category, edge type, edge direction, and edge activation condition, ensuring the consistency between the rule semantics and the graph structure expression.

[0038] Third, generate conflict arbitration metadata, assign static priority to each rule, and provide a default arbitration strategy when it conflicts with other rules, thereby forming a definite conflict resolution entry point when rules are superimposed, avoiding non-convergence caused by mutual rule rejection during the solution phase.

[0039] During implementation, executable constraint functions are used for candidate placement verification, graph construction metadata is used for constraint dependency graph construction, and conflict arbitration metadata is used for conflict resolution. This ensures that business rules maintain a consistent semantic meaning throughout candidate action verification, graph structure generation, and rule conflict handling. Furthermore, when constructing the constraint dependency graph, aggregated business rules can be mapped to aggregated edges, isolated business rules to conflict edges, and load-bearing or protective constraints to directed dependency edges, based on rule category and edge type.

[0040] In this implementation, after being compiled into multiple products driven by the Abstract Syntax Tree (AST), business rules no longer exist merely as independent text rules or external validation conditions. Instead, they are incorporated into the candidate placement validation, constraint dependency graph construction, and conflict resolution processes as constraint functions, graph construction metadata, and arbitration metadata, respectively. This approach bridges the gap between the rule language familiar to business users and the computational model executed by the computer. Through compiler technology, the business logic becomes programmable and interpretable. This not only reduces system maintenance costs (rules can be added or deleted without modifying the code), but more importantly, it unambiguously and structurally injects ambiguous business requirements into the constraint checking, graph structure generation, and conflict governance stages of the optimization algorithm, ensuring the business compliance of the solution.

[0041] In this implementation, multi-product compilation driven by Abstract Syntax Tree (AST) transforms the rule text maintainable by business personnel into constraint functions that can be called by the solver, graphable metadata, and arbitrable priority strategies, enabling the rules to be consistent across the three stages of constraint checking, constraint graph construction, and conflict resolution.

[0042] Furthermore, during implementation, to filter out unnecessary conflicts, a dynamic sparsity coefficient σ(t) can be introduced as a core indicator to measure the complexity of the constraint graph. At time t (corresponding to the t-th dynamic insertion or re-optimization iteration), σ(t) is defined as: in, This represents the L0 norm of the matrix (i.e., the number of non-zero elements).

[0043] Execution rule pre-compilation subroutine, for A raw Perform structured pruning to generate a sparse constraint matrix A sparse The specific algorithm is as follows: Semantic sharding: Utilizing the mutual exclusion relationships in the rule base, N SKUs are divided into M mutually exclusive clusters {C1, C2, ..., CM}. Goods within a cluster have strong constraints, while goods between clusters have no direct constraint edges by default unless a specific global rule (such as a total weight limit) is triggered.

[0044] Threshold truncation: Set a dynamic threshold in μ The adjustment factor is set to 2.5 (preferred value). All... a ij Set the weak constraint edge <τ(t) to zero: Block diagonalization rearrangement: The Reverse Cuthill-McKee (RCM) algorithm is applied to rearrange the rows and columns of the matrix so that non-zero elements are clustered near the diagonal as much as possible, forming a block diagonal-dominated structure.

[0045] After the above processing, the dynamic sparsity coefficient changes from the initial σ raw ≈0.85 significantly decreased to σ sparse (t)<0.05.

[0046] Because A sparse It exhibits block diagonal dominance and extreme sparsity, with its matrix-vector multiplication complexity ranging from O(N) to O(N). 2 The complexity of solving related linear systems using the iterative method (conjugate gradient method) is reduced from O(N) to O(ηN) (where η is the average node degree, and in the experiment η≈4). Furthermore, the complexity of solving related linear systems using the iterative method (conjugate gradient method) is reduced from O(N) to O(ηN). 3 ) reduced to O(NlogN It is even approximately linear O(N).

[0047] In the above embodiments, preferably, the specific process for resolving conflicting business rules includes: Based on the static priority of rules in the arbitration metadata and the default arbitration strategy of conflicting rule pairs, the initial arbitration result is determined. For example, when security rules conflict with business preference rules, the security rules are given priority to form an executable initial arbitration statement.

[0048] During operation, upon detecting an order change event or container change event, the loading feasibility of different arbitration options is evaluated based on the updated container loading status (e.g., occupied space, layer and relative position of loaded SKUs, local remaining gap shape, etc.) and the constraint check results of the executable constraint function. Combined with the priority score and position preference vector output by the constraint-aware graph neural network on the updated heterogeneous state graph, the conflict cost function is constructed. The conflict cost function comprehensively represents the priority of the conflict rule, the degree of violation of the current loading status, and the expected loss of the overall loading rate due to adjusting the corresponding rule.

[0049] Based on minimizing the conflict cost function and following the default arbitration strategy, the initial arbitration result is adjusted to generate the runtime arbitration result: when a certain arbitration caliber causes the candidate placement to fail continuously or triggers a chain of infeasibility in the current state, the system can downgrade or temporarily deactivate the low-priority rule in the conflict rule pair, so that the arbitration result matches the current packing state and avoids repeated rollbacks within the affected domain due to rigid arbitration.

[0050] The decision log records the triggering conditions for rule conflicts, the identifier of the conflicting rule, the applicable default arbitration strategy, the static priority, the arbitration result during operation, the constraint check result corresponding to the arbitration result during operation, and the cost value corresponding to the conflict cost function. This log can be used to determine when a conflict is triggered, why a rule is downgraded, the corresponding verification failure point, and the cost difference corresponding to different arbitration options, thereby improving the traceability and explainability of rule governance.

[0051] In this implementation, the initial framework is determined by static priority and default arbitration strategy. During runtime, a conflict cost function is constructed based on the loading feasibility represented by the current binning state, constraint check results, and graph reasoning results for dynamic adjustment. At the same time, combined with log recording, the conflict rules can still maintain executability under different binning states, reducing infeasible solutions and repeated trials caused by rule conflicts, and improving the stability and auditability of the dynamic binning process.

[0052] In the above implementation, preferably, the edges of the constraint dependency graph include aggregation edges, conflict edges, and directed dependency edges; the edge type is generated by the business rule category, and the aggregation relationship rule of "same customer concentration" is mapped to aggregation edges: when two SKUs meet the same customer or same aggregation conditions, an aggregation edge is created between them to express that they should meet the proximity / same area constraint in relative position, and positive enhancement weights are applied to the aggregation of neighbor information corresponding to the aggregation edge in the subsequent graph neural network message passing process, thereby strengthening the tendency of SKUs that meet the aggregation business rules to be placed close to each other or in the same area.

[0053] For isolation-related business rules such as hazardous materials isolation, conflict edges are created between SKU pairs that meet the isolation trigger conditions. These conflict edges express mutually exclusive placement semantics, guiding the relevant SKUs to spatial locations that meet the isolation distance or isolation partition requirements during the solution phase, thus preventing them from forming illegal adjacencies with other SKUs. In the subsequent graph neural network message passing process, an inhibition factor is introduced into the aggregation of neighbor information corresponding to the conflict edges to weaken the weight of conflict node features in the aggregation result, thereby reducing the attraction of candidate placements that violate isolation rules to the current node's decision.

[0054] For rules involving the transmission of load-bearing or protective constraints, directed dependency edges are created, and the edge direction is determined by the graph construction metadata. For example, the heavy object points to a potential lighter object above it to transmit the load-bearing constraint. This allows the load-bearing risk above to be propagated along the direction during candidate action evaluation and local re-optimization, thereby reducing placement attempts that violate the load-bearing / protection rules. In the subsequent message passing process of the graph neural network, a directional mask is introduced to the aggregation of neighbor information corresponding to the directed dependency edge. This allows constraint features to propagate only along the edge direction of the directed dependency edge, and masks message propagation in the opposite direction.

[0055] During implementation, the DSL (domain-specific language) compiler maps each business rule to a specific edge type, for example: same customer → Aggregation edge (undirected, positively reinforcing weight, encourages proximity); hazardous isolate → Conflict edge (undirected, inhibits aggregation, forces separation); heavy below →Directed dependency edge (directed, from the heavy object to the potential light object above it, transmitting load-bearing constraints); fragile protect →Directed dependency edge (directed, from the fragile item to the area above, transmitting protective constraints).

[0056] During graph structure generation, all loading unit pairs are traversed. Loading units include SKUs and virtual trays, and corresponding edges are dynamically created according to DSL rules. For example, if two SKUs have the same customer ID, an aggregation edge is added between them.

[0057] Let the set of SKUs to be packed be Q={q1,q2,…,qN}, where N is the total number of goods.

[0058] First, construct the initial fully connected weighted adjacency matrix A. raw ∈RN×N. Matrix element a ij The strength of the original constraint conflict between goods i and goods j is defined as: Where K is the total number of rules in the rule base (e.g., hazardous materials isolation, heavy items not being overweight, same order aggregation, etc.). w k The weight coefficient of the k-th rule (hard constraint) w k →∞, soft constraints w k ∈(0,1]); I(·) is an indicator function that takes the value 1 if the rule is violated, otherwise takes the value 0.

[0059] In this implementation, by establishing differentiated expressions for three types of edges—aggregation, conflict, and directed dependency—for different rule semantics, the constraint dependency graph can characterize the interaction relationships of multiple rules in a structured manner, providing a computable constraint association basis for subsequent pruning and scoring, and reducing global conflicts caused by relying solely on local if-then rules.

[0060] Based on the graph structure disclosed in the above implementation method, a constraint-aware heterogeneous graph neural network (CA-GNN) is established using a relational graph convolutional network (R-GCN) architecture. Independent relation transformation parameters are configured for aggregation edges, conflict edges, and directed dependency edges, and specific message passing is performed according to edge type. During message passing, nodes aggregate neighbor information that satisfies the same customer or group conditions through aggregation edges, and amplify the features of such neighbors through positive reinforcement weights; they perceive conflict signals such as mutual exclusion of hazardous materials through conflict edges, and weaken the weight of conflict node features in the aggregation result through suppression factors; they perceive load-bearing or protective transmission constraints through directed dependency edges, and restrict information propagation only along the edge direction through directional masks.

[0061] Specifically, in the message passing process of the graph neural network, a given node to be evaluated receives messages from aggregated edge neighbors, conflicting edge neighbors, and directed dependent edge neighbors. Aggregated edge neighbors transmit positive association information encouraging proximity or placement within the same region; conflicting edge neighbors transmit inhibitory information representing constraints such as mutual exclusion and isolation requirements; and directed dependent edge neighbors transmit load-bearing or protective constraint information propagating along a predetermined direction. The system employs different processing methods for neighbor messages of different edge types, ensuring that when updating features, the same node can both strengthen the influence of objects that should be close and suppress the influence of objects that should be isolated, while also adhering to the directional propagation requirements of load-bearing and protective relationships.

[0062] In one embodiment, after two to three layers of message passing, each node's features not only include its own physical, business, and state attributes, but also incorporate the constraint effects from other loading units with which it has aggregation, conflict, and directed dependency relationships. Thus, node features are no longer merely encoding local attributes of a single SKU, but rather become a structured representation containing a global constraint context.

[0063] This design enables GNNs to explicitly learn and reason about interactions between complex rules. For example, for a SKU belonging to the same customer's order, the node features will gradually strengthen the aggregation signal of "should be close to other SKUs from the same customer"; for a hazardous SKU, the node features will gradually strengthen the conflict signal of "should be isolated from other ordinary SKUs"; for fragile or heavy SKUs, the node features will gradually accumulate the dependency signal of "should adhere to the load-bearing direction or protection direction".

[0064] The feature vector is input into a decision network, which outputs the priority score and position preference vector for the SKU. Strong constraints generate strong signals during graph propagation, ensuring that relevant SKUs are preferentially placed in positions that satisfy the constraints. CA-GNN transforms complex, multi-source, and structured business rules into graph-structured data for learning. Its advantage lies in its ability to explicitly model the complex relationships between SKUs and, through the representation learning capabilities of neural networks, automatically infer a globally coordinated placement strategy that satisfies all constraints. This solves the problem that traditional rule engines can only handle "if-then" local rules, which easily leads to global conflicts.

[0065] In the implementation process, the following scenario will be used as an example to illustrate how to transform rules into graphs and perform learning and reasoning.

[0066] (1) Specific data example for constructing the graph: Scenario: There are 4 SKUs: A1 (customer Alice, general), A2 (customer Alice, general), B1 (customer Bob, dangerous goods), and C1 (customer Carol, fragile goods).

[0067] (2) Node features (simplified example): A1:[0.2,0.2,0.3,0.05,1,0,0,0,1,0,...], represents (normalized dimensions, weight, customer Alice's one-hot code [1,0,0], fragile item identifier 0); B1:[0.25,0.25,0.4,0.08,0,1,0,1,0,0,...], indicates (Customer Bob code [0,1,0], Dangerous goods label 1); C1:[0.15,0.15,0.5,0.02,0,0,1,0,0,1,...], indicates (Customer Carol code [0,0,1], fragile item identifier 1).

[0068] (3) Edge construction (based on DSL metadata): Aggregate edge: Create an undirected edge between A1 and A2 (because the clients are the same). Conflict edges: Establish undirected edges between B1 and A1, A2, and C1 respectively (because B1 is a hazardous material and needs to be isolated). Directed Dependency Edges: Establish directed edges from C1 to A1, A2, and B1 (because C1 is a fragile item and cannot be weighed down, so protective constraints need to be transmitted to potential objects placed above it).

[0069] (4) Numerical representation of GNN message passing: Assume the initial node features are h A1 (0),h B1 (0)....

[0070] First layer of propagation: For node A1, during message transmission, it will receive aggregation relationship information from A2, conflict relationship information from B1, and protection dependency information from C1. After multiple layers of propagation, A1's characteristics will simultaneously reflect multiple signals such as "should be close to A2", "should be far away from B1", and "must comply with the protection constraints transmitted by C1".

[0071] For node B1, its features will strongly aggregate conflict constraint signals with other nodes, making it exhibit a higher priority for isolation and placement in subsequent decisions.

[0072] (5) Decision output and application: The GNN outputs the final feature z for each SKU. i.

[0073] z i Inputting a fully connected layer (decision head) yields: Priority score p i For example, p of B1 B1 =0.9 (very high), A1's p A1 =0.5, p of C1 C1 =0.7. The optimizer will prioritize placing high-scoring SKUs to ensure that hazardous material B1 is first placed in an isolated location; Location preference vector v i For example, B1's v B1 This could represent a preference coordinate (0.9, 0.9, 0.1) (a corner of the container), and C1's v C1 This may indicate a preference (0.5, 0.5, 0.8) (upper middle layer).

[0074] Subsequent local re-optimization or heuristic search will refer to these p i and v i This guides the search and significantly reduces randomness.

[0075] In the above embodiments, preferably, the specific process of determining the influence domain includes: The three-dimensional space of the container is discretized into a voxel grid (e.g., with a voxel side length of 5cm, i.e., a resolution of 5cm), and a spatial hash index from voxels to SKU identifiers is established to quickly locate the voxel set occupied by the SKU and to quickly determine whether a candidate placement area is empty.

[0076] When an order change or box change occurs, starting from the change node associated with the change event, the set of logically associated nodes is obtained by traversing along the activated aggregate edges, conflict edges, and / or directed dependency edges in the constraint dependency graph. At the same time, the set of geometrically adjacent candidate voxels is obtained by traversing along the voxel grid, and the set of geometrically adjacent candidate voxels is mapped to the set of geometrically adjacent candidate nodes based on the spatial hash index.

[0077] During the traversal, logical weights are determined based on edge type, edge weight, and path length in the path from the changed node to the candidate node in the constraint dependency graph, and logical-geometric coupling between the changed node and the candidate node is calculated based on the geometric distance between the changed node and the candidate node in the voxel mesh.

[0078] When a candidate node and a changed node are geometrically adjacent and their logical-geometric coupling meets the basic threshold, the corresponding candidate node is included in the set of geometrically adjacent candidate nodes; or, when a candidate node and a changed node are not geometrically adjacent but their logical weight reaches the preset logical inclusion threshold, the corresponding candidate node is included in the set of logically associated candidate nodes.

[0079] If a node with a logical weight higher than the preset high weight threshold is found within the current search radius, the search radius is expanded; if candidate nodes with a logical-geometric coupling degree lower than the preset pruning threshold are found consecutively during the traversal and the current accumulated logical weight has not reached the critical threshold, the traversal of the corresponding branch is terminated.

[0080] Perform weighted fusion or union on the set of geometrically adjacent candidate nodes and the set of logically related candidate nodes, and determine the final influence domain based on the result of the weighted fusion or union.

[0081] Therefore, the influence domain is no longer determined solely by the expansion of geometric gaps, but is jointly determined by geometric adjacency and business logic topology. This allows SKUs that are not geometrically adjacent but are strongly related in business to be included in the local rearrangement, while pruning and excluding SKUs that are geometrically close but logically unrelated.

[0082] Specifically, for the currently changing node u and its neighboring node v to be evaluated, the coupling degree Suv is defined as: in, W logic (u,v) (Logical Weight): Calculated based on the path from u to v in the Constraint Dependency Graph (CDG).

[0083] If there are direct strong constraint edges (such as "must be on the same pallet" or "mutually exclusive") W logic Take the higher value (e.g., 10.0). If there are indirect weak constraints (e.g., "same customer but different pallets"), W logic The number of hops decreases with path length (e.g., 0.8k, where k is the number of hops). If there is no logical connection, W logic =0.

[0084] in, D geo ( u , v (Geometric distance): The Euclidean or Manhattan distance between nodes u and v in a 3D voxel mesh.

[0085] in, α (Distance attenuation coefficient) controls the penalty force of geometric distance on coupling degree, and is usually taken as α∈[1,2]. (Smoothing term) is a small constant (such as 10⁻⁶) to prevent the denominator from being zero.

[0086] I( Type uv(Directional indicator function): If the constraint is a directed dependency (e.g., u must be below v), and the traversal direction violates the dependency direction, then I=0 (direct pruning). If it is an undirected conflict or a forward dependency, then I=1.

[0087] A dynamic threshold Θdynamic is set to determine whether node v is included in the influence domain Ω: Inclusion condition: If Suv≥Θbase, then v∈Ω.

[0088] Radius adaptive expansion: Initialize the search radius Rinit. If a high logical weight node (Wlogic>Whigh) is found within the radius R, the search radius is automatically expanded to R′=R×(1+β·Wlogic), where β is the expansion coefficient.

[0089] Early termination (pruning): If, during the traversal, the Suv of N consecutive nodes is lower than Θprune (low threshold), and the current accumulated logical weight has not reached the critical threshold, then the traversal of that branch is terminated immediately, even if the geometric distance is still within the normal range.

[0090] Compared to traditional fixed-radius search, this scheme reduces the number of invalid nodes involved in computation while maintaining high solution quality, significantly reducing the inference time of CA-GNN and achieving intelligent pruning of the search space. Through the long-tail effect of logical weights, the local algorithm "sees" distant business constraints, avoiding expensive global reordering caused by violations of business rules, thus achieving local awareness of global constraints. The threshold mechanism enables the algorithm to dynamically adjust computational resources according to the strength of business rules. The more complex the rule and the stronger the dependency, the larger the search range automatically becomes; when the rule is simple, it automatically shrinks, achieving a dynamic balance between computational efficiency and solution quality.

[0091] In this implementation, by using voxelized spatial representation, constraint dependency graph logical association analysis, and a dynamic threshold pruning mechanism driven by logical-geometric coupling, change processing is focused on the SKUs and spatial regions that are truly relevant to the current event, avoiding full-box scanning and global recalculation. This makes the dynamic adjustment complexity related to the strength of local business dependencies and the local spatial range, supporting second-level response.

[0092] In an optional implementation, the propagation of the impact of the changed node on the candidate node can also be quantitatively evaluated using a probabilistic model based on hop count decay. Specifically, let the current packing state diagram be G=(V,E), where V is the set of already placed goods, |V|=N. When a new goods q new Upon arrival, define its influence domain V. impact V represents all factors q new The set of cargo nodes that need to be re-evaluated for placement or have their coordinates adjusted due to insertion.

[0093] This embodiment introduces a constraint propagation attenuation factor γ∈(0,1) to quantify the propagation attenuation characteristics of constraint conflicts in the graph structure. For any node v in the graph, let its relationship with q be... new The shortest graph distance (HopDistance) is h = dist(q) new ,v).

[0094] Node v is included in the influence domain V impact The probability P(v∈V) impact It follows an exponential decay law: Wherein, γ is the constraint propagation attenuation coefficient, which physically means that the influence of constraint conflict attenuates to γ ​​times its original value after each layer of neighbor relationships. Under the rule compilation mechanism of this system, due to the rapid convergence of soft constraint weights, experiments show that γ≈0.45~0.55 (the preferred value is 0.5).

[0095] β is the initial disturbance strength, which depends on q. new The degree of matching between the physical properties (volume, weight, hazard level) and the current local density, β∈(0,1). If q new If a hard constraint is triggered (such as mutual exclusion of hazardous materials), then β=1; if it is only spatial compression, then β<1.

[0096] During implementation, a fixed search radius is not preset, but rather determined based on a confidence threshold. Calculate the minimum necessary radius R dynamically.

[0097] Define N h (q new ) is q new In graph G, the set of nodes within the h-hop neighborhood is |N h | is its base.

[0098] Set target confidence level =0.99 (i.e., covering 99% of potential conflict risks). The influence radius R is defined as the smallest integer satisfying the following inequality: Substituting into the probability formula, it simplifies to: Where E[ΔCost] is the expected change in total cost (such as space utilization loss or number of moves). C threshold The minimum effective cost threshold preset for the system is used to filter out minor disturbances.

[0099] Algorithm execution flow: 1. Initialization: Let h=1, and the cumulative probability S=0.

[0100] 2. Iterative accumulation: Get the number of h-hop neighbors |Nh| (which can be quickly obtained using Breadth-First Search (BFS)).

[0101] Calculate the current layer contribution value ΔSh=∣Nh∣·γh·β.

[0102] Update the cumulative value S←S+ΔSh.

[0103] 3. Termination Judgment: If S≥ · C threshold If so, let R = h, and stop the iteration.

[0104] If h>h max (Preset maximum safety radius, e.g., 10), force stop and set R=h max .

[0105] 4. Output: Determine the influence domain subgraph The optimization solver is invoked only on nodes within the subgraph.

[0106] This embodiment demonstrates that the expected value E[R] of the dynamic radius R is independent of the total cargo volume N, i.e., it is asymptotically bounded. This is achieved by introducing γ (attenuation factor) and... (Confidence level) Two adjustable scientific parameters are used to dynamically determine the influence domain radius R by solving the probability accumulation inequality, replacing the fuzzy empirical radius and elevating pruning from a heuristic strategy to a mathematical algorithm based on probability guarantees.

[0107] In the above embodiments, preferably, the specific process of generating an action set within the influence domain and performing pruning and local re-optimization on the action set includes: The search order of the loading units to be placed is determined based on the priority scores output by the constraint-aware graph neural network, and the search range of candidate placement coordinates is limited based on the position preference vector. A multi-scale void index is maintained for the voids inside the container, such as using a hierarchical spatial index structure to support void retrieval from coarse to fine granular. At the same time, the set of maximum void cuboids is pre-computed to quickly obtain candidate empty boxes in the currently available space that may accommodate a loading unit to be placed.

[0108] After generating the action set within the influence domain, a geometric pre-screening is performed: for each candidate action in the action set (including the unit to be placed, candidate orientation, and candidate coordinates), the multi-scale gap index and the set of largest gap cuboids are used to determine whether there is a gap cuboid that can accommodate a certain orientation of the unit to be placed; if not, the action is directly eliminated to reduce invalid attempts in subsequent placement, verification, and rollback. For example, when attempting to insert a new SKU, the system first quickly queries whether there is a gap that can accommodate a certain orientation of the SKU, and prioritizes the use of candidate orientations with higher orientation priority for higher-priority units to be placed within the candidate region defined by the position preference vector, thereby greatly reducing invalid placement-rollback attempts and accelerating the local solution process.

[0109] For candidate actions retained after geometric pre-screening, the verification order is determined according to a preset orientation priority rule (e.g., prioritizing orientations that better match the size ratio or are easier to fit the cuboid with gaps). Temporary placement simulation and constraint checks are performed for each placement orientation: the temporary placement simulation maps the unit to be placed into an occupied voxel set in voxel space and writes it into a temporary occupied state; the constraint check calls constraint functions to determine conditions such as collision, isolation, and load-bearing; if the verification fails, the temporary occupied state is revoked and the system switches to the next orientation or the next coordinate, thus forming a closed-loop logic of simulation, verification, and revocation during the pruning phase. For candidate actions that pass the constraint check, local re-optimization candidate actions are determined by combining the arbitration result, priority score, and position preference vector, and the target action is selected from these and backfilled into the current packing scheme.

[0110] In this implementation, action generation and search range limitation driven by priority scores and position preference vectors, combined with geometric pre-screening using gap index and maximum empty box pre-computation, significantly reduce invalid actions caused by inability to accommodate. Through temporary placement simulation and fast undo, the set of feasible actions can be converged in advance during the pruning stage, reducing the search depth and rollback cost of local re-optimization.

[0111] During implementation, for example, in the following scenarios, the process of influencing domain location and layout rearrangement is as follows: Scenario: A 40-foot container is partially loaded. Customer A already has products A1 and A2 in the container. Now, we need to add a new SKU, A3, with dimensions (25, 25, 40) cm for customer A.

[0112] Step 1: Locate logical associations and geometrically adjacent regions: Find the current positions of A1 and A2 using the index. Assume they are concentrated in an area at the front of the container.

[0113] At the same time, based on the same customer concentration rule, the aggregation relationship between A3 and A1 and A2 is identified in the constraint dependency graph, and the set of logically related nodes is obtained from the change node corresponding to A3 along the activated aggregation edge.

[0114] Step 2: Determine the area of ​​influence: In the voxel grid, obtain the set of geometrically adjacent candidate voxels around the regions where A1 and A2 are located, and obtain the set of geometrically adjacent candidate nodes based on spatial hash index mapping; then, combine the logical weights and geometric distances from A3 to A1 and A2 to calculate the logical-geometric coupling degree.

[0115] When A1, A2, and A3 meet the logical inclusion condition or the geometric coupling condition, they are included in the corresponding candidate node set. Subsequently, a weighted fusion or union is performed on the logically associated candidate node set and the geometrically adjacent candidate node set to obtain the final influence domain.

[0116] Step 3: Local optimization solution: The search order of A1, A2, and A3 is determined based on priority scores, and the search range of candidate placement coordinates is limited based on position preference vectors, forming a set of actions that includes the selection of the loading unit to be placed, the selection of the placement orientation, and the selection of the placement coordinates.

[0117] Within the vacated influence domain voxel space, a fast local re-optimization process is used: First, use the multi-scale gap index and the set of maximum gap cuboids to perform geometric pre-screening on the candidate actions corresponding to A1, A2 and A3; Then, for the candidate actions retained after geometric pre-screening, the placement orientation is verified in sequence according to the preset orientation priority rules, and temporary placement simulation and constraint check are performed. For candidate actions that pass the constraint check, local re-optimization candidate actions are determined by combining the arbitration result, priority score and position preference vector, and the target action is selected from them.

[0118] The entire process only involves local action generation, pruning, and re-optimization of a small number of loaded units within the influence domain, resulting in a shallow search depth.

[0119] Step 4: Scheme Integration: Write the new local layout (the new positions of A1, A2, and A3) back to the voxel mesh, update the voxelMap, and backfill it into the current packing scheme. All other parts of the container remain completely unchanged.

[0120] As can be seen from this example, regardless of whether there are 500 or 1000 SKUs in the container, the computational complexity of this insertion operation is mainly related to the number of loading units in the influence domain, the scale of candidate actions, and the local gap structure, thus ensuring completion within 10 seconds.

[0121] In the above embodiments, preferably, the nodes in the heterogeneous state graph include virtual trays, and the process of generating virtual trays includes: Clustering is performed on the SKU set based on its physical and business attributes to generate a set of virtual pallets, where each virtual pallet corresponds to a subset of the SKU set. Clustering considers both physical attributes (volume, aspect ratio, length-to-height ratio, width-to-height ratio, etc.) and business attributes (customer, category, hazardous materials label, etc.) to ensure consistency in geometric composability and business merging among SKUs within the same virtual pallet.

[0122] In one implementation, a hybrid clustering method is performed on the SKU set based on the SKU's volume, aspect ratio, and business attributes to generate a virtual tray set. Simultaneously, based on the aggregation edges in the constraint dependency graph, SKUs satisfying the aggregation business rules are subject to the same virtual tray merging constraint. Furthermore, based on the conflict edges in the constraint dependency graph, conflicts between the aggregation and isolation rules are identified, and SKUs triggering conflicts are assigned to independent dedicated virtual trays. Therefore, the formation of virtual trays no longer depends solely on general physical attribute clustering but is simultaneously constrained by the business logic relationships represented by both aggregation and conflict edges.

[0123] For each virtual tray member SKU, internal pre-arrangement is performed in discrete space representation to determine the minimum bounding cuboid, thereby determining the size of the virtual tray's bounding cuboid. Member SKUs are first mapped to voxel occupancy scale at voxel resolution, and then a rapid pre-arrangement strategy such as first-fit is used to obtain a rough internal layout. Based on this, the length, width, and height of the bounding cuboid are calculated, thus obtaining the size of the virtual tray's bounding cuboid. Further, based on the member SKU's weight, business attributes, and bounding cuboid size, aggregation features of the corresponding virtual tray nodes are generated, and the virtual tray nodes and their aggregation features are written into the heterogeneous state graph.

[0124] After the virtual pallet size is determined, a pallet-level packing plan is generated within the container using the virtual pallet as the loading unit. This reduces the decision-making object from thousands of SKUs to a smaller number of loading units. Once the pallet-level packing plan is determined, the member SKUs within each virtual pallet are refined to further fill gaps in the fixed space inside the pallet and complete the final coordinate and orientation placement of each SKU, generating a packing plan. In one implementation, under the constraint of the arbitration result, a pallet-level packing plan is generated within the container using the virtual pallet as the loading unit. When pallet-level packing fails or the loading rate of the pallet-level packing plan is lower than a preset threshold, the clustering parameters used for hybrid clustering are adjusted, and the generation of the virtual pallet set, internal pre-arrangement, and pallet-level packing are re-executed. After obtaining a pallet-level packing plan that meets the preset threshold, the member SKUs within each virtual pallet are refined to generate the current packing plan.

[0125] Specifically, a hybrid clustering algorithm (such as K-Means variants or hierarchical clustering) based on volume, aspect ratio, and business tags (e.g., customer, category) is used to dynamically generate "virtual pallets." The size of each pallet is not fixed but dynamically determined based on the minimum bounding cuboid of its internally pre-assigned SKU set. During the pre-grouping phase, aggregation edges and conflict edges in the constraint dependency graph are used for analysis: for SKUs that meet aggregation conditions such as same customer concentration, the system prioritizes merging them into the same virtual pallet; for SKU sets that simultaneously trigger conflict rules such as "same customer concentration" and "dangerous goods isolation," the system identifies rule conflicts based on conflict edges and assigns the conflicting SKUs to independent dedicated virtual pallets to avoid global conflicts during subsequent layout. Simultaneously, when pallet-level packing fails or the loading rate falls below a preset threshold, the system can regenerate the virtual pallet set by adjusting clustering parameters to improve the feasibility and loading rate of pallet-level packing. This step transforms the optimization problem of thousands of SKU-items into a virtual pallet placement problem with harmonious internal constraints on the order of hundreds or even tens of items. After the pallet-level packing scheme meets the preset threshold, the original SKUs within each virtual pallet are then finely arranged to further fill the gaps within the pallet and maximize space utilization. The core of this mechanism is "divide and conquer." By introducing a "virtual pallet" as an intermediate layer, the high-dimensional, mixed SKU packing problem is decomposed into two low-dimensional, more regular sub-problems (grouping and layout). This avoids directly searching through massive SKU combinations and solves the problems of slow solution speed and low loading rate caused by the explosion of the search space in traditional methods.

[0126] In this implementation, by introducing virtual pallet layering, the packing of high-dimensional mixed SKUs is decomposed into low-dimensional sub-problems of grouping / pallet-level layout / intra-pallet fine arrangement, which significantly reduces the search space size. Furthermore, by writing virtual pallet nodes and their aggregation features into the heterogeneous state graph and performing clustering parameter feedback adjustment when pallet-level packing fails, the loading rate and solution stability are improved.

[0127] Specifically, in the implementation process, the steps of a specific implementation example include: Input: A list of SKUs to be packed. Each SKU has attributes such as physical dimensions (length L, width W, height H, in centimeters), weight, customer ID, category, and hazard label.

[0128] Feature vector: Calculate the feature vector F for each SKU. i =[V i ,L i / W i ,L i / H i W i / H i[, onehot (customer), onehot (category), ...], where V i =L i W i H i .

[0129] Step 1: Hard rule pre-grouping (creating initial clusters): Operation: Traverse all SKUs and perform the first round of grouping based on strong isolation rules (such as dangerous goods) and strong aggregation rules (such as customer VIPs).

[0130] Example: For SKUs that trigger strong isolation rules, an initial cluster can be formed separately or assigned to an independent dedicated virtual tray based on the conflict edge identification results; All SKUs with customer ID=VIP001 and category=fragile items are merged to form an initial cluster.

[0131] Step 2: Physical attribute clustering (refined grouping): Operation: For each non-strongly constrained initial cluster (or remaining SKU), perform physical property clustering using the improved K-Medoids algorithm.

[0132] Specific calculation example (assuming there are 5 regular SKUs): Clustering process: Set the target cluster number K=2, and randomly select S1 and S3 as the initial center points (Medoid).

[0133] Calculate the distance from each SKU to the two centers, where the distance is defined as: For example, the distance from S2 to S1 Distance from S2 to S3 Therefore, S2 is assigned to the cluster where S1 is located.

[0134] After all points have been assigned, the point that minimizes the sum of intra-cluster distances is selected as the new center point within each cluster. Ultimately, S1 and S4 may form cluster C1 (small and square), and S3 and S5 may form cluster C2 (long and narrow).

[0135] Step 3: Virtual tray size calculation and voxelization: Operation: For each cluster, perform a fast internal pre-arrangement in a voxel grid (assuming 5cm resolution) to determine its minimum bounding cuboid.

[0136] Example (for clusters C1:S1,S4): Convert S1(20,20,30) and S4(22,18,40) into voxels: S1 occupies 4×4×6 voxels, and S4 occupies 5×4×8 voxels (rounded up).

[0137] In the virtual space, try placing the elements using the "first-fit" algorithm: first place S1 at (0,0,0), then try placing S4 next to S1. Assuming they are placed side-by-side, the required total width is 4 times the width of S1 + 5 times the width of S4 = 9 voxels.

[0138] Therefore, the virtual tray dimensions required for cluster C1 are: length = 9 voxels (45cm), width = 4 voxels (20cm), height = 8 voxels (40cm) (determined by the height of S4).

[0139] Meanwhile, based on the weight, business attributes, and circumscribed cuboid dimensions of the member SKUs in cluster C1, aggregate features can be generated for the virtual tray and written into the heterogeneous state graph as the feature representation of the corresponding virtual tray node.

[0140] Output: Generates a virtual tray object containing: tray ID, size, list of member SKUs, and an internal, coarse SKU pre-layout coordinate.

[0141] Through the above example steps, the original 1200 SKUs can be compressed into approximately 65 virtual pallets. Subsequent optimization only requires determining the positions of these 65 pallets within the container, reducing the search space from the order of 1200! to the order of 65!. Furthermore, the internal structure of each pallet is relatively fixed, making it solvable. If, during the pallet-level packing stage, the existing virtual pallet combinations fail to reach the preset loading rate threshold, the clustering parameters can be adjusted and the above clustering and pallet generation process re-executed to obtain new virtual pallet partitioning results.

[0142] This invention also proposes a real-time dynamic packing optimization system for highly mixed SKUs, used to implement the real-time dynamic packing optimization method for highly mixed SKUs disclosed in any of the above embodiments, including: The data access module is used to acquire loading tasks and output container parameters, the set of SKUs to be loaded, and the current loading status; The rule compilation module is used to compile business rules described in a domain-specific language into executable constraint functions and graph construction metadata, and output arbitration metadata for conflict resolution. The rule arbitration module is used to resolve conflicts in business rules based on arbitration metadata and output arbitration results as input for subsequent rule solutions.

[0143] The graph construction module is used to construct a constraint dependency graph based on the SKU set, the current packing status, and graph construction metadata. It generates virtual pallet nodes and their aggregation features based on the volume, aspect ratio, and business attributes of the SKUs, combined with the aggregation edges and conflict edges in the constraint dependency graph. It constructs a geometric graph by extracting the geometric adjacency relationships between SKUs or virtual pallets from the voxel mesh obtained by discretizing the container's three-dimensional space. Finally, it merges the constraint dependency graph, the geometric graph, and the virtual pallet nodes to generate a heterogeneous state graph.

[0144] The influence domain analysis module updates the current packing status, constraint dependency graph, geometric graph, and heterogeneous state graph when an order change event or container change event is triggered. It obtains a set of logically related nodes based on the topological connectivity of the constraint dependency graph, obtains a set of geometrically adjacent candidate voxels based on the geometric adjacency of the voxel mesh, and obtains a set of geometrically adjacent nodes based on spatial index mapping. It also includes SKUs or virtual pallets that are not geometrically adjacent but have business constraint relationships in the constraint dependency graph into the set of logically related nodes. It performs a weighted fusion or union of the set of logically related nodes and the set of geometrically adjacent nodes, and determines the final influence domain based on the result of the weighted fusion or union.

[0145] The graph neural reasoning module is used to input the updated heterogeneous state graph corresponding to the influence domain into the constraint-aware graph neural network. It performs feature aggregation for aggregated edges, conflicting edges, and directed dependent edges using a message passing method bound to the edge type, and outputs priority scores and position preference vectors.

[0146] The action pruning and local re-optimization module is used to generate an action set within the influence domain, and perform pruning and local re-optimization on the action set based on the executable constraint function, arbitration result, priority score and position preference vector, and backfill the target action obtained by local re-optimization into the current packing scheme.

[0147] The solution output module is used to update the current packing scheme based on the local re-optimization results and output the updated packing scheme.

[0148] In this implementation, after receiving the loading task, the data access module outputs not only container parameters and the set of SKUs to be loaded, but also the current loading status, ensuring that subsequent graph construction, influence domain analysis, and local re-optimization are all based on this current loading status. After parsing the DSL business rules, the rule compilation module generates graph construction metadata to map aggregation-type business rules, isolation-type business rules, and load-bearing or protection constraints as aggregation edges, conflict edges, and directed dependency edges, respectively, allowing the business rules to directly enter the constraint dependency graph construction process.

[0149] When the graph construction module enters the bin packing solution phase, it no longer only constructs the constraint dependency graph, but further extracts the geometric adjacency relationships between SKUs or virtual trays based on voxel meshes to construct a geometric graph. It then merges the constraint dependency graph, the geometric graph, and the virtual tray nodes into a heterogeneous state graph. Thus, business logic relationships and spatial geometric relationships can be expressed in a unified graph structure, enabling the system to simultaneously perceive rule constraints and spatial adjacency states.

[0150] When order change or container change events are triggered, the influence domain analysis module no longer determines the influence domain solely based on the constraint dependency graph and spatial hash index. Instead, it obtains a set of logically related nodes through the topological connectivity of the constraint dependency graph, obtains a set of geometrically adjacent candidate voxels through the geometric adjacency of the voxel grid, and maps them to a set of geometrically adjacent nodes. SKUs or virtual pallets that are geometrically non-adjacent but business-related are included in the set of logically related nodes. Then, a weighted fusion or union of the two sets is performed to obtain the final influence domain. This avoids the problem of missing strongly business-related nodes when determining the local rearrangement range solely based on geometric proximity.

[0151] The graph neural inference module inputs the updated heterogeneous state graph corresponding to the influence domain into the constraint-aware graph neural network, and performs feature aggregation for aggregated edges, conflicting edges, and directed dependent edges using a message-passing method bound to the edge type, thereby outputting a priority score and a position preference vector. The priority score is used to characterize the search priority of the loading unit within the current influence domain, and the position preference vector is used to characterize the preferred region for candidate placement coordinates.

[0152] The action pruning and local re-optimization module generates an action set within the influence domain based on priority scores and position preference vectors. It then performs pruning and local re-optimization by combining executable constraint functions and arbitration results. The target actions obtained from the local re-optimization are then backfilled into the current bin packing scheme. Thus, the system no longer relies on global recalculation but instead completes rapid repair and incremental updates within a local scope related to the change event.

[0153] In this implementation, by breaking down the method logic into a modular collaborative architecture that includes rule compilation arbitration, heterogeneous state graph construction, influence domain analysis, graph neural reasoning, action pruning and local re-optimization, and output, the system can maintain scalable data stream processing and stable real-time response capabilities under conditions of thousands of SKUs and frequent dynamic events.

[0154] In the above embodiments, preferably, the graph neural reasoning module adopts a multi-relation graph convolutional structure, configures different relation transformation parameters for different edge types, and performs specific message passing for aggregation edges, conflict edges, and directed dependency edges respectively.

[0155] For aggregation edges, the corresponding neighbor information aggregation adopts a positive enhancement weight, which makes loading units that meet the aggregation business rules more inclined to be placed close together or in the same area in the graph representation space. Loading units include SKUs and virtual trays. For example, for loading units that meet conditions such as customer concentration, aggregation edges can strengthen their mutual attraction feature contribution during message passing, making subsequent decisions more inclined to arrange them in adjacent or same-area locations.

[0156] For conflict edges, a suppression factor is introduced into the aggregation of corresponding neighbor information to weaken the weight of conflict node features in the aggregation result. For example, for business rules such as hazardous materials isolation, when there is a conflict edge between two loading units, the graph neural network no longer simply superimposes the features of adjacent nodes when aggregating this type of neighbor information, but instead applies suppression to these features, making the constraint signals that should be avoided or cannot be adjacent more prominent in the node representation.

[0157] For directed dependent edges, the corresponding neighbor information aggregation introduces a directional mask, and the propagation of messages in the opposite direction to the directed dependent edge is blocked. For example, under load-bearing or protection constraints such as heavy objects below and heavy objects above fragile items, messages are only allowed to propagate in the dependent direction, so that the load-bearing risk or protection requirement of the lower loading unit is transmitted to the upper candidate loading unit, but reverse propagation is not allowed, thus ensuring that the graph reasoning result conforms to the physical constraint direction.

[0158] During implementation, the DSL compiler maps business rules to edge types in the graph, enabling the graph neural network to explicitly perceive and comply with business constraints when learning the spatial relationships of loading units. After performing multi-layer message passing on the updated heterogeneous state graph, the graph neural inference module outputs a priority score and a position preference vector for each loading unit. The priority score characterizes the search priority of the loading unit within the current influence domain, and the position preference vector limits the search range of candidate placement coordinates.

[0159] The action pruning and local re-optimization module determines the search order of the action set based on priority scores and limits the search range of candidate placement coordinates based on position preference vectors. It then sorts the candidate actions that pass the constraint checks, combining priority scores and position preference vectors, to select the target action. Thus, bin packing optimization no longer relies solely on geometric matching or local heuristics, but incorporates business rules, physical dependencies, and graph reasoning results into the candidate action evaluation process.

[0160] In this implementation, by configuring different relation transformation parameters for different edge types in the graph neural inference module, and performing specific message passing on aggregated edges, conflicting edges, and directed dependency edges respectively, differentiated modeling of business aggregation relationships, isolation relationships, and load-bearing / protection dependency relationships is achieved. At the same time, by outputting priority scores and position preference vectors and driving subsequent action sorting and coordinate search range limitation, the targeting of action selection, the rule compliance of bin packing schemes, and the efficiency of local re-optimization are improved.

[0161] In the above embodiments, preferably, the system further includes a spatial indexing module. This module is used to establish a voxel grid and a spatial hash index, and to extract geometric adjacency relationships between SKUs or virtual pallets based on the voxel grid. Specifically, the voxel grid is used to discretize the three-dimensional space of the container, and the spatial hash index is used to quickly index voxel occupancy information, mapping the geometric adjacency relationships at the voxel level to geometric adjacency relationships at the SKU or virtual pallet level. These geometric adjacency relationships characterize the spatial proximity of SKUs or virtual pallets, thus providing a geometric basis for subsequent influence domain analysis.

[0162] The influence domain analysis module determines the logical weight of a path based on the edge type, edge weight, and path length in the path from the changed node to the candidate node in the constraint dependency graph, and calculates the logical-geometric coupling degree based on the geometric distance between the changed node and the candidate node in the voxel grid. Specifically, the logical weight of the path characterizes the strength of the business association between the candidate node and the changed node, the geometric distance characterizes their proximity in the container space, and the logical-geometric coupling degree comprehensively describes whether the candidate node should be included in the local rearrangement.

[0163] When a candidate node and a changed node are geometrically adjacent and their logical-geometric coupling meets a basic threshold, the corresponding candidate node is included in the set of geometrically adjacent candidate nodes. Alternatively, when a candidate node and a changed node are not geometrically adjacent but their path logical weight reaches a preset logical inclusion threshold, the corresponding candidate node is included in the set of logically related candidate nodes. Thus, influence domain analysis no longer relies solely on geometric proximity but can include geometrically non-adjacent SKUs or virtual trays that are strongly related in business logic within the reordering scope.

[0164] During the influence domain expansion process, when a node with a logical weight higher than a preset high-weight threshold is found within the current search radius, the system expands the search radius. If, during the traversal, candidate nodes with a logical-geometric coupling degree lower than a preset pruning threshold are encountered consecutively and the current accumulated logical weight has not reached a critical threshold, the system terminates the traversal of the corresponding branch. Therefore, influence domain expansion no longer employs a fixed-range search but dynamically adjusts the search range based on the strength of logical association and geometric proximity, avoiding ineffective expansion.

[0165] After obtaining the set of geometrically adjacent candidate nodes and the set of logically related candidate nodes, the influence domain analysis module performs a weighted fusion or union of the two sets, and determines the final influence domain based on the result of the weighted fusion or union. Thus, the final influence domain reflects both the propagation range of the change event in the business logic topology and its local impact range in the geometric space.

[0166] In this implementation, a voxel grid and a spatial hash index are established through a spatial index module, and the final influence domain is determined by an influence domain analysis module based on path logical weight, geometric distance, logical-geometric coupling degree, and dynamic threshold mechanism. This enables the local reordering range to be adaptively adjusted according to the business correlation strength and spatial influence degree of the change event, reducing the probability of irrelevant nodes being included in the reordering process and improving the accuracy of influence domain analysis and dynamic update efficiency.

[0167] The real-time dynamic packing optimization system for highly mixed SKUs disclosed in the above embodiments has modules whose functions correspond to the steps of the real-time dynamic packing optimization method for highly mixed SKUs disclosed in the above embodiments. During implementation, the above embodiments are referred to for operation, and will not be repeated here.

[0168] The real-time dynamic packing optimization method and system for highly mixed SKUs disclosed in the above embodiments will be described in detail through the following examples.

[0169] Example 1: Intelligent packing of initial highly mixed orders (heterogeneous state graph-driven solution based on rules, i.e., structure) Scenario: Receive a batch of mixed cross-border e-commerce orders from 3 customers (A, B, and C), totaling 1200 SKUs. These include general merchandise, VIP fragile items from customer A, UN3480 lithium batteries (dangerous goods) from customer B, and promotional items from customer C. The task is to satisfy all 25 constraint rules and generate a solution with a high loading rate within a preset timeframe.

[0170] System action flow: 1. Perception and Rule Compilation: The system receives order data and the DSL rule set. The rule compilation module parses the DSL rules and generates executable constraint functions, graph construction metadata, and arbitration metadata. The compiler transforms rules such as prioritizing the placement of VIP customer goods in the pressure-resistant zone and requiring lithium batteries to be placed in a dedicated isolation zone into constraint functions for candidate placement verification, graph construction metadata for constructing aggregated edges / conflicting edges / directed dependency edges, and a default arbitration strategy for conflict resolution.

[0171] 2. Virtual tray pre-grouping and heterogeneous state graph construction: First, the system performs a first-level grouping based on customer ID and hazardous material label. Then, it identifies mergeable and conflicting SKUs based on aggregation and conflicting edges in the constraint dependency graph. Customer B's lithium batteries are assigned to a separate dedicated virtual tray because they trigger an isolation rule.

[0172] Then, within each non-hazardous goods customer group, hybrid clustering is performed based on the SKU's (length, width, height, aspect ratio, volume) characteristics. For example, customer A's 120 SKUs are clustered into several virtual pallets, one of which is dedicated to holding their VIP fragile items.

[0173] Ultimately, the 1200 SKUs were grouped into virtual trays, a significantly smaller number than the original total number of SKUs, including trays specifically for lithium batteries. Subsequently, the system extracted the geometric adjacency relationships between SKUs or virtual trays based on a voxel mesh to construct a geometric graph, and then fused the constraint dependency graph, the geometric graph, and the virtual tray nodes to generate a heterogeneous state graph.

[0174] 3. Constrained Perceptual Map Neural Reasoning and Action Generation: The system constructs a heterogeneous state graph with virtual pallets as nodes. Based on the compiled metadata, aggregation edges are added between pallet nodes belonging to the same customer, conflict edges are added between the "lithium battery pallet" and all other pallets, and directed dependency edges are added between loading units with load-bearing or protection requirements.

[0175] CA-GNN performs message passing on this graph. Specifically, it uses positive boosting weights for aggregating neighbor information corresponding to aggregated edges, introduces a suppression factor for aggregating neighbor information corresponding to conflicting edges, and introduces a directional mask for aggregating neighbor information corresponding to directed dependent edges. The "lithium battery tray" node receives a strong rejection signal, and its output features will contain the semantics "must be placed in an isolated area."

[0176] Based on the priority scores and position preference vectors output by the GNN, the system generates a set of actions within the candidate coordinate range, and performs geometric pre-screening, orientation verification, and action pruning by combining executable constraint functions and arbitration results. In the pallet-level packing stage, the system performs layout search and optimization to generate an initial layout, achieving a relatively good overall loading rate.

[0177] 4. Fine arrangement of SKUs within the tray: For each placed virtual tray, the system performs secondary optimization and arrangement of the original SKUs within its fixed internal space, further filling the gaps within the tray and ultimately improving the overall space utilization.

[0178] Example 2: Incremental Re-optimization Driven by Temporary Order Additions and Logical-Geometric Dual Influence Domains Scenario: After the packing plan in Example 1 has been issued to the warehouse for execution, an urgent order is received: add two ordinary items (A3, A4) for customer A, and add one ordinary item (D1) for customer D. An adjustment plan must be provided within 10 seconds, while minimizing disruption to most of the original goods in the boxes.

[0179] System action flow: 1. Event Triggering and Impact Domain Location: The system first updates the current packing state, constraint dependency graph, and geometry graph, and then merges them to generate an updated heterogeneous state graph.

[0180] For the newly added A3 and A4, the system starts from the corresponding change node, traverses along the activated aggregate edge in the constraint dependency graph, identifies the set of logically related nodes where customer A's existing products A1 and A2 are located; at the same time, it traverses along the voxel grid to obtain the set of geometrically adjacent candidate voxels surrounding the regions of A1 and A2, and maps them to obtain the set of geometrically adjacent nodes.

[0181] For the newly added D1, since it is a brand new customer, the system searches for candidate geometric adjacent regions that match its size and business constraints in the current geometry graph, and at the same time calculates its logical weight and geometric distance with the existing loading unit.

[0182] 2. Determining the influence domain and dynamic pruning: The system determines logical weights based on the edge type, edge weight, and path length of the path from the changed node to the candidate node in the constraint dependency graph, and calculates the logical-geometric coupling degree based on the geometric distance between the changed node and the candidate node in the voxel mesh.

[0183] When a candidate node is geometrically adjacent to a changed node and its coupling degree meets the basic threshold, it is included in the set of geometrically adjacent candidate nodes. When a candidate node is not geometrically adjacent but its logical weight reaches the preset logical inclusion threshold, it is included in the set of logically related candidate nodes. If a high logical weight node is found within the current search radius, the search radius is automatically expanded. If low coupling nodes appear consecutively and the cumulative logical weight has not reached the key threshold, the corresponding branch traversal is terminated early.

[0184] Finally, a weighted fusion or union of the logically related candidate node set and the geometrically adjacent candidate node set is performed to determine the final influence domain.

[0185] 3. Local deconstruction and rearrangement: The system temporarily removes all relevant products (A1, A2) within the "influence domain A" and forms a local set to be rearranged with A3 and A4; for D1, a local rearrangement set is formed within its corresponding influence domain.

[0186] The system determines the search order of A1, A2, A3, A4 and D1 based on priority scores, and limits the search range of candidate placement coordinates based on position preference vectors. Then, it performs geometric pre-screening using gap index and the set of largest gap cuboids, and then sorts and re-optimizes candidate actions by combining constraint functions, arbitration results and priority scores.

[0187] 4. Solution Integration and Output: Local optimization is completed within the preset dynamic response time limit, generating a new local layout. The system seamlessly "embeds" this layout into the original global solution, keeping all other areas (including Customer B's lithium battery area and Customer C's area) completely unchanged. The final output is an updated 3D packing diagram.

[0188] Example 3: Hot Update of Business Rules and System Adaptation Scenario: The company has added a "carbon neutral" product line, and the operations department wants to add a new rule for these products: RULECarbonNeutralZone: IF item.carbon neutral == True THEN GROUP TOGETHER INUPPER LAYER (Carbon-neutralized products are placed on the top layer of the box).

[0189] System action flow: 1. Hot Deployment of DSL Rules: Operations personnel submit the above DSL rule text through the management interface. No system restart or code modification is required.

[0190] 2. Real-time compilation by the compiler: The DSL compiler analyzes new rules in real time and generates: The new constraint function check_carbon_neutral_zone(...) is used to verify whether carbon-neutral products meet the upper-level placement constraints; The new graph construction metadata is used to map the "GROUP TOGETHER" semantics between carbon-neutral commodities to aggregate edges, and to map "UPPER" to... LAYER "The semantics are transformed into position-constrained validation conditions;" Arbitration strategy: When this rule conflicts with the rule for heavy objects, the latter shall be given priority (safety first).

[0191] 3. System Adaptation: During the next binning or dynamic optimization, the graph building module will automatically recognize the presence of carbon. neutral =True tags for SKUs and add aggregation edges between them; at the same time, the executable constraint function will introduce its upper-level placement requirements into the candidate action validation process.

[0192] GNN learns the aggregation signals of carbon-neutral commodities through new aggregation edge relationships, guiding the algorithm to preferentially place them in the upper layer of the container.

[0193] If a conflict arises regarding placing "heavy carbon neutrality products" at the top level, the arbitrator will adjust them to the middle or lower level according to the preset priority, but will still try to maintain their relative concentration with other carbon neutrality products.

[0194] From rule definition to system integration and activation, the entire process requires no developer intervention, enabling rapid iteration of business strategies and ensuring compliance of new rules in all subsequent optimization schemes. Thus, the system achieves rapid hot updates and immediate activation of new business rules through a unified process logic encompassing rule compilation, graph construction, arbitration governance, and local re-optimization.

[0195] The above are merely preferred embodiments of the present invention and are not intended to limit the present invention. Various modifications and variations can be made to the present invention by those skilled in the art. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the scope of protection of the present invention.

Claims

1. A real-time dynamic packing optimization method for highly mixed SKUs, characterized in that, include: Obtain a loading task, which includes container parameters, a set of SKUs to be loaded, and the current loading status. Each SKU in the SKU set is associated with dimensions, weight, and business attributes. The business rules described in a domain-specific language are parsed to generate executable constraint functions, graph construction metadata, and arbitration metadata. The graph construction metadata is used to map aggregated business rules to aggregated edges, isolated business rules to conflict edges, and load-bearing constraints or protection constraints to directed dependency edges, and records the edge direction, edge activation conditions, and edge weights. Based on the SKU set, the current packing status, and the graph construction metadata, a constraint dependency graph is constructed. Geometric adjacency relationships between SKUs or virtual pallets are extracted from the voxel mesh obtained by discretizing the three-dimensional space of the container to construct a geometric graph. The constraint dependency graph and the geometric graph are fused to generate a heterogeneous state graph. The nodes in the heterogeneous state graph represent SKUs or virtual pallets, and the edges include aggregated edges, conflicting edges, and directed dependency edges obtained by business rule mapping, as well as geometric association edges formed by the geometric adjacency relationships. Based on the arbitration metadata, conflicting business rules are resolved, and the current packing scheme is obtained under the constraints of the arbitration result. When an order change event or container change event is detected, the current packing status, the constraint dependency graph, and the geometry graph are updated and fused to generate an updated heterogeneous state graph. Starting from the change node associated with the change event, the set of logically associated nodes is obtained by traversing along the activated aggregation edges, conflict edges, and / or directed dependency edges in the constraint dependency graph. The set of geometrically adjacent nodes is obtained by traversing along the voxel grid. SKUs or virtual pallets that are not geometrically adjacent but have business constraint associations in the constraint dependency graph are included in the set of logically associated nodes. The set of logically associated nodes and the set of geometrically adjacent nodes are weighted and fused or the union is taken to determine the influence domain based on the result of the weighted fusion or union. The updated heterogeneous state graph corresponding to the influence domain is input into the constraint-aware graph neural network. The feature aggregation is performed by the message passing function bound to the edge type for different edge types. In this case, the neighbor information aggregation corresponding to the conflict edge is introduced with an inhibition factor, and the neighbor information aggregation corresponding to the directed dependency edge is introduced with a directional mask. The priority score and position preference vector of each SKU or virtual tray in the influence domain are output. Within the influence domain, an action set is generated based on the priority score and the position preference vector. Based on the executable constraint function, the arbitration result, the priority score, and the position preference vector, pruning and local re-optimization are performed on the action set. The local re-optimization result is then backfilled into the current bin packing scheme to obtain an updated bin packing scheme.

2. The real-time dynamic packing optimization method for highly mixed SKUs according to claim 1, characterized in that, The parsing process uses business rules described in a domain-specific language to generate executable constraint functions, graph construction metadata, and arbitration metadata, including: Based on abstract syntax tree-driven multi-product compilation, business rules are compiled into constraint functions for candidate placement verification, graph construction metadata for constructing the constraint dependency graph, and arbitration metadata for conflict resolution. The graph construction metadata includes rule identifier, rule category, edge type, edge direction, edge activation condition, and edge weight. The rule category includes at least aggregation business rules, isolation business rules, and load-bearing constraints or protection constraints. The edge type includes at least aggregation edges, conflict edges, and directed dependency edges. The graph builder generates corresponding edges between SKUs or virtual trays that meet the rule conditions based on the edge activation conditions. The arbitration metadata includes the static priority of rules and the default arbitration strategy for conflicting rule pairs. The executable constraint function is called for candidate placement verification. The graph construction metadata is called for constraint dependency graph construction. The arbitration metadata is called for conflict resolution.

3. The real-time dynamic packing optimization method for highly mixed SKUs according to claim 2, characterized in that, The specific process for resolving conflicts in conflicting business rules includes: The initial arbitration result is determined based on the static priority of the rules and the default arbitration strategy of the conflicting rule pairs; After detecting an order change event or container change event, a conflict cost function is constructed based on the updated current loading status, the constraint check results of the executable constraint function, and the priority score and position preference vector output by the constraint-aware graph neural network. The conflict cost function comprehensively represents the priority of the conflict rule, the degree of violation of the current loading status, and the expected loss of the overall loading rate due to adjusting the corresponding rule. Based on minimizing the conflict cost function and in accordance with the default arbitration strategy, the low-priority rules in the conflict rule pair are downgraded or temporarily deactivated to generate runtime arbitration results. Record the rule conflict triggering conditions, conflict rule identifier, applicable default arbitration strategy, static priority, runtime arbitration result and the constraint check result corresponding to the runtime arbitration result, as well as the cost value corresponding to the conflict cost function, to form a decision log.

4. The real-time dynamic packing optimization method for highly mixed SKUs according to claim 2, characterized in that, The constraint-aware graph neural network configures independent relation transformation parameters for aggregation edges, conflict edges, and directed dependency edges, and performs specific message passing according to edge type, specifically including: For the aggregation of neighbor information corresponding to the aggregation edge, a positive enhancement weight is adopted to enhance the tendency of SKUs or virtual trays that meet the aggregation business rules to be placed close to each other or in the same area. An inhibition factor is introduced for the aggregation of neighbor information corresponding to conflict edges to reduce the weight of conflict node features in the aggregation result; A directional mask is introduced for the aggregation of neighbor information corresponding to directed dependent edges. The constraint features are propagated only along the edge direction of the directed dependent edge, and the propagation of messages in the opposite direction to the edge direction is masked.

5. The real-time dynamic packing optimization method for highly mixed SKUs according to claim 1, characterized in that, The influence domain is determined based on the set of logically related nodes and the set of geometrically adjacent nodes, including: Logical weights are determined based on edge type, edge weight, and path length in the path from the changed node to the candidate node in the constraint dependency graph, and logical-geometric coupling degree between the changed node and the candidate node is calculated based on the geometric distance between the changed node and the candidate node in the voxel mesh. When the candidate node is geometrically adjacent to the changed node and the logical-geometric coupling degree meets the basic threshold, the corresponding candidate node is included in the set of geometrically adjacent candidate nodes; or, when the candidate node is not geometrically adjacent to the changed node but the logical weight reaches the preset logical inclusion threshold, the corresponding candidate node is included in the set of logically associated candidate nodes. If a node with a logical weight higher than the preset high weight threshold is found within the current search radius, the search radius is expanded. If, during the traversal, candidate nodes with a logical-geometric coupling degree lower than the preset pruning threshold appear consecutively and the current accumulated logical weight has not reached the critical threshold, the traversal of the corresponding branch is terminated. A weighted fusion or union is performed on the set of geometrically adjacent candidate nodes and the set of logically related candidate nodes, and the final influence domain is determined based on the result of the weighted fusion or union.

6. The real-time dynamic packing optimization method for highly mixed SKUs according to claim 1, characterized in that, The step of generating an action set within the influence domain and performing pruning and local re-optimization on the action set includes: Generate a set of actions that include the selection of the loading unit to be placed, the selection of the placement orientation, and the selection of the placement coordinates; The search order of the loading units to be placed is determined based on the priority score, and the search range of the candidate placement coordinates is limited based on the position preference vector; Maintain the multi-scale void index of the voids inside the container, and pre-compute the set of the largest void cuboids; Based on the multi-scale gap index and the set of largest gap cuboids, the action set is geometrically pre-screened to eliminate actions that cannot accommodate the loading unit to be placed. For candidate actions retained after geometric pre-screening, the verification order of placement orientation is determined according to a preset orientation priority rule, and temporary placement simulation and constraint check are performed on each placement orientation verified in the verification order. If the constraint check fails, the occupation state generated by the temporary placement simulation is cancelled. For candidate actions that pass the constraint check, local re-optimization candidate actions are determined by combining the arbitration result, the priority score, and the position preference vector, and target actions are selected from them and backfilled into the current packing scheme.

7. The real-time dynamic packing optimization method for highly mixed SKUs according to claim 1, characterized in that, The nodes in the heterogeneous state graph include virtual trays, and the generation of the virtual trays includes: Based on the SKU's volume, aspect ratio, and business attributes, perform hybrid clustering on the SKU set to generate a virtual tray set; Based on the aggregation edges in the constraint dependency graph, the same virtual tray merging constraint is applied to SKUs that satisfy the aggregation business rules, and the conflict between the aggregation rules and the isolation rules is identified based on the conflict edges in the constraint dependency graph. SKUs that trigger the conflict are assigned to independent dedicated virtual trays. In the discrete space representation, the member SKUs of each virtual tray are pre-arranged internally to determine the minimum circumscribed cuboid, thereby determining the size of the circumscribed cuboid of the virtual tray. Based on the weight, business attributes and circumscribed cuboid size of the member SKUs, the aggregation features of the corresponding virtual tray nodes are generated, and the virtual tray nodes and their aggregation features are written into the heterogeneous state diagram. Under the constraints of the arbitration result, a pallet-level packing scheme is generated in the container using the virtual pallet as the loading unit. When the pallet-level packing fails or the loading rate of the pallet-level packing scheme is lower than a preset threshold, the clustering parameters used for the hybrid clustering are adjusted, and the virtual pallet set generation, internal pre-arrangement, and pallet-level packing are re-executed. After obtaining a pallet-level packing scheme that meets the preset threshold, the member SKUs in each virtual pallet are refined and arranged to generate the current packing scheme.

8. A real-time dynamic packing optimization system for highly mixed SKUs, characterized in that, include: The data access module is used to acquire loading tasks and output container parameters, the set of SKUs to be loaded, and the current loading status; The rule compilation module is used to parse business rules described in a domain-specific language and generate executable constraint functions, graph construction metadata, and arbitration metadata. The rule arbitration module is used to resolve conflicts between conflicting business rules based on the arbitration metadata and output the arbitration result. The graph construction module is used to construct a constraint dependency graph based on the SKU set, the current packing status, and the graph construction metadata; generate virtual pallet nodes and their aggregation features based on the volume, aspect ratio, and business attributes of the SKUs and in combination with the aggregation edges and conflict edges in the constraint dependency graph; construct a geometric graph by extracting the geometric adjacency relationships between SKUs or virtual pallets from the voxel mesh obtained by discretizing the container's three-dimensional space; and fuse the constraint dependency graph, the geometric graph, and the virtual pallet nodes to generate a heterogeneous state graph, wherein the edges in the heterogeneous state graph include aggregation edges, conflict edges, directed dependency edges, and geometric association edges. The influence domain analysis module is used to update the current packing status, the constraint dependency graph, the geometry graph, and the heterogeneous state graph when an order change event or container change event is triggered. It obtains a set of logically related nodes based on the topological connectivity of the constraint dependency graph and a set of geometrically adjacent nodes based on the geometric adjacency of the voxel mesh. It also includes SKUs or virtual pallets that are not geometrically adjacent but have business constraint relationships in the constraint dependency graph into the set of logically related nodes. It performs a weighted fusion or union on the set of logically related nodes and the set of geometrically adjacent nodes, and determines the final influence domain based on the result of the weighted fusion or union. The graph neural reasoning module is used to input the updated heterogeneous state graph corresponding to the influence domain into the constraint-aware graph neural network, and to perform feature aggregation for aggregated edges, conflicting edges and directed dependent edges using a message passing method bound to the edge type, and output priority scores and position preference vectors. The action pruning and local re-optimization module is used to generate an action set within the influence domain, and perform pruning and local re-optimization on the action set based on the executable constraint function, the arbitration result, the priority score, and the position preference vector, and backfill the target action obtained from the local re-optimization into the current packing scheme; The solution output module is used to update the current packing scheme based on the local re-optimization results and output the updated packing scheme.

9. The real-time dynamic packing optimization system for highly mixed SKUs according to claim 8, characterized in that, The graph neural reasoning module adopts a multi-relation graph convolutional structure, configures different relation transformation parameters for different edge types, and performs specific message passing for aggregation edges, conflict edges, and directed dependency edges respectively. Specifically, positive enhancement weights are used for the aggregation of neighbor information corresponding to aggregation edges, an inhibition factor is introduced for the aggregation of neighbor information corresponding to conflict edges, a directional mask is introduced for the aggregation of neighbor information corresponding to directed dependency edges, and message propagation with the opposite edge direction to the directed dependency edge is shielded. The output of the graph neural reasoning module includes a priority score and a position preference vector corresponding to the loading unit; The action pruning and local re-optimization module determines the search order of the action set based on the priority score, limits the search range of candidate placement coordinates based on the position preference vector, and sorts the candidate actions that pass the constraint check by combining the priority score and the position preference vector to select the target action.

10. The real-time dynamic packing optimization system for highly mixed SKUs according to claim 8, characterized in that, It also includes a spatial indexing module, which is used to establish a voxel grid and a spatial hash index, and extract the geometric adjacency relationship between SKUs or virtual trays based on the voxel grid; The influence domain analysis module is used to determine the path logical weight based on the edge type, edge weight and path length in the path from the change node to the candidate node in the constraint dependency graph, and to calculate the logical-geometric coupling degree based on the geometric distance between the change node and the candidate node in the voxel mesh. When a candidate node and a changed node are geometrically adjacent and the logical-geometric coupling degree meets the basic threshold, the corresponding candidate node is included in the set of geometrically adjacent candidate nodes; or when a candidate node and a changed node are not geometrically adjacent but the path logical weight reaches the preset logical inclusion threshold, the corresponding candidate node is included in the set of logically associated candidate nodes. Influence domain expansion and branch termination control are performed based on basic threshold, high weight threshold, pruning threshold and key threshold. Weighted fusion or union is performed on the geometrically adjacent candidate node set and the logically related candidate node set to determine the final influence domain based on the result of weighted fusion or union.

Images