Large-scale integer linear programming solving method and system

Abstract

The invention provides a large-scale integer linear programming solving method and system, and belongs to the field of artificial intelligence, and the method comprises the steps: constructing a feasible solution pool according to a to-be-solved integer linear programming problem instance, and determining a current solution; performing iterative optimization on the feasible solution pool and the current solution to obtain an optimized target solution; in each round of iterative optimization, determining a variable selection probability of each decision variable based on a difference between a statistical feature of each feasible solution in a current feasible solution pool and a current solution; according to the current solving state characteristics, determining neighborhood scale parameters of current iteration; and according to the variable selection probability and the neighborhood scale parameter, constructing and solving a sub-problem of the current iteration to obtain a new feasible solution, and updating the feasible solution pool and the current solution. According to the method, the variable selection strategy based on the solution pool statistical characteristics and the neighborhood scale adaptive determination strategy based on the current solution state are combined, so that accurate construction and efficient iterative solution of the sub-problems in the large-scale integer linear programming problem are realized.

Description

Technical Field

[0001] This invention relates to the field of artificial intelligence technology, and in particular to a method and system for solving large-scale integer linear programming problems. Background Technology

[0002] Integer Linear Programming (ILP) is a key mathematical tool for solving complex combinatorial optimization problems. As the scale of problems in practical applications expands to tens of thousands of variables, finding high-quality approximate solutions within a limited time budget has become a research focus in both industry and academia.

[0003] To solve such problems, existing techniques typically employ Large Neighborhood Search (LNS) algorithms. These algorithms rely primarily on manually designed heuristic rules (such as random selection or propagation rules based on the current solution) to select the variables to be optimized, and usually pre-set a fixed neighborhood size parameter to control the size of the subproblems.

[0004] However, the aforementioned existing technologies have limitations when solving large-scale problems. On the one hand, selecting variables based solely on the local state of the current solution or random mechanisms makes the search process highly unpredictable, making it difficult to accurately locate key variables and resulting in low convergence efficiency. On the other hand, a fixed neighborhood size is difficult to adapt to dynamically changing solution states, easily leading to local optima due to an excessively small neighborhood, or situations where subproblems cannot be solved within a limited time due to an excessively large neighborhood. Consequently, the speed and quality of solving large-scale integer linear programming problems are both low. Summary of the Invention

[0005] This invention provides a method, system, electronic device, storage medium, and computer program product for solving large-scale integer linear programming problems, in order to overcome the deficiencies in the prior art and improve the speed and quality of solving large-scale integer linear programming problems.

[0006] This invention provides a method for solving large-scale integer linear programming problems, comprising the following steps: Based on the instance of the integer linear programming problem to be solved, construct a feasible solution pool containing multiple initial feasible solutions and determine the current solution; The feasible solution pool and the current solution are iteratively optimized until a preset termination condition is met, and the optimized target solution is obtained. In each round of iterative optimization, the following steps are performed: Based on the difference between the statistical characteristics of each feasible solution in the current feasible solution pool and the current solution, the variable selection probability of each decision variable in the integer linear programming problem instance is determined; Based on the current solution state characteristics of the integer linear programming problem instance, determine the neighborhood size parameter for the current iteration; Based on the variable selection probability and the neighborhood size parameter, construct the sub-problem for the current iteration; The solver is invoked to solve the subproblem, a new feasible solution is obtained, and the feasible solution pool and the current solution are updated using the new feasible solution.

[0007] According to a method for solving large-scale integer linear programming problems provided by the present invention, determining the variable selection probability of each decision variable in the integer linear programming problem instance based on the difference between the statistical characteristics of each feasible solution in the current feasible solution pool and the current solution includes: The ranking of each feasible solution is determined based on the objective function value of each feasible solution in the feasible solution pool; Based on the ranking, the values ​​of each decision variable in each feasible solution in the feasible solution pool are weighted, summed, and normalized to obtain the confidence score of each decision variable; Calculate the difference between the value of each decision variable in the current solution and the corresponding confidence score, and obtain the initial selection probability of each decision variable based on the difference; Determine the maximum and minimum probability values ​​among all the initial selection probabilities; The initial selection probability is numerically corrected based on the maximum probability value and the minimum probability value to obtain the variable selection probability; the numerical correction is used to limit the ratio between the maximum probability value and the minimum probability value.

[0008] According to a method for solving large-scale integer linear programming problems provided by the present invention, determining the neighborhood size parameter for the current iteration based on the current solution state characteristics of the integer linear programming problem instance includes: The integer linear programming problem instance is modeled as a bipartite graph, and the variable node features, constraint node features, and edge structure features in the bipartite graph are extracted as the solution state features. The solved state features are input into a pre-trained reinforcement learning policy network to obtain the action distribution parameters output by the reinforcement learning policy network. Based on the action distribution parameters, the neighborhood size parameter of the current iteration is determined by sampling.

[0009] According to a method for solving large-scale integer linear programming provided by the present invention, the step of sampling based on the action distribution parameters to determine the neighborhood size parameter of the current iteration includes: Construct a Gaussian distribution based on the action distribution parameters; Multiple samples are taken from the Gaussian distribution, and the sampled values ​​within a preset interval are retained to obtain valid sampling results; the upper limit of the preset interval is the sum of the mean and standard deviation of the Gaussian distribution; The neighborhood size parameter is determined by multiplying the effective sampling results by the total number of variables in the integer linear programming problem instance.

[0010] According to a method for solving large-scale integer linear programming problems provided by the present invention, the step of constructing a sub-problem for the current iteration based on the variable selection probability and the neighborhood size parameter includes: Based on the variable selection probability, variables equal to the neighborhood size parameter are sampled non-replaced from all decision variables of the integer linear programming problem instance to form a set of variables to be optimized. When constructing the subproblem, the decision variables in the set of variables to be optimized are retained as variables, and the values ​​of the decision variables outside the set of variables to be optimized are fixed to the values ​​of the corresponding decision variables in the current solution.

[0011] According to a method for solving large-scale integer linear programming problems provided by the present invention, updating the feasible solution pool and the current solution using the new feasible solution includes: If the objective function value of the new feasible solution is better than the objective function value of the current solution, then the new feasible solution is updated to the new current solution, and the new feasible solution is added to the feasible solution pool; If the objective function value of the new feasible solution is worse than that of the current solution, then the similarity between the new feasible solution and the existing feasible solutions in the feasible solution pool is calculated. If the similarity is lower than a preset similarity threshold, the new feasible solution is added to the feasible solution pool.

[0012] According to the present invention, a method for solving large-scale integer linear programming problems includes, in part, constructing a feasible solution pool containing multiple initial feasible solutions and determining the current solution based on an instance of the integer linear programming problem to be solved. Set an initial time limit for the solution; The solver is used to solve the integer linear programming problem instance, and the solver callback mechanism is activated. When the solver callback mechanism detects that the number of feasible solutions generated by the solver reaches a preset threshold, or the solution time reaches the time limit, the initial solution process is terminated. All feasible solutions generated in the initial solution phase are collected to construct the feasible solution pool, and the solution with the optimal objective function value in the feasible solution pool is determined as the current solution.

[0013] This invention also provides a large-scale integer linear programming solution system, comprising the following modules: The first processing module is used to construct a feasible solution pool containing multiple initial feasible solutions and determine the current solution based on the instance of the integer linear programming problem to be solved; The second processing module is used to iteratively optimize the feasible solution pool and the current solution until a preset termination condition is met to obtain the optimized target solution. In each round of iterative optimization, the following steps are performed: based on the difference between the statistical characteristics of each feasible solution in the current feasible solution pool and the current solution, the variable selection probability of each decision variable in the integer linear programming problem instance is determined; based on the current solution state characteristics of the integer linear programming problem instance, the neighborhood size parameter of the current iteration is determined; based on the variable selection probability and the neighborhood size parameter, a subproblem of the current iteration is constructed; the solver is invoked to solve the subproblem to obtain a new feasible solution, and the feasible solution pool and the current solution are updated using the new feasible solution.

[0014] The present invention also provides an electronic device, including a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the program to implement any of the large-scale integer linear programming solution methods described above.

[0015] The present invention also provides a non-transitory computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements the large-scale integer linear programming solution method as described above.

[0016] The present invention also provides a computer program product, including a computer program that, when executed by a processor, implements any of the above-described methods for solving large-scale integer linear programming problems.

[0017] In summary, one or more technical solutions provided in the embodiments of this application have at least the following technical effects or advantages: By constructing a feasible solution pool containing multiple initial feasible solutions, a rich statistical foundation is provided for subsequent iterative searches. During the iterative optimization process, the probability of variable selection is determined by analyzing the differences between the statistical characteristics of each feasible solution in the current feasible solution pool and the current solution. This allows for full utilization of the distribution patterns of historical high-quality solutions to accurately identify key variables that deviate from the characteristics of high-quality solutions and have optimization potential, avoiding the low search efficiency caused by blindly and randomly selecting variables in traditional methods. Simultaneously, by dynamically determining the neighborhood size parameter based on the current solution state characteristics of the integer linear programming problem instance, adaptive adjustment of the subproblem size is achieved. This resolves the contradiction that a fixed neighborhood size can easily lead to subproblems that are too large to solve or too small to fall into local optima in large-scale problems, maximizing the search breadth while ensuring the solvability of subproblems. Finally, by continuously updating the solution pool and the current solution using new feasible solutions, real-time dynamic calibration of statistical information is achieved, significantly improving the solution speed and quality of large-scale integer linear programming problems. Attached Figure Description

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

[0019] Figure 1 This is one of the flowcharts illustrating the large-scale integer linear programming solution method provided by this invention.

[0020] Figure 2 This is the second flowchart of the large-scale integer linear programming solution method provided by this invention.

[0021] Figure 3 This is the third flowchart of the large-scale integer linear programming solution method provided by this invention.

[0022] Figure 4 This is the fourth flowchart of the large-scale integer linear programming solution method provided by this invention.

[0023] Figure 5 This is the fifth flowchart of the large-scale integer linear programming solution method provided by this invention.

[0024] Figure 6 This is the sixth flowchart of the large-scale integer linear programming solution method provided by this invention.

[0025] Figure 7 This is the seventh flowchart of the large-scale integer linear programming solution method provided by this invention.

[0026] Figure 8 This is a flowchart illustrating the overall framework for solving large-scale integer linear programming problems provided by the present invention.

[0027] Figure 9 This is a schematic diagram of the structure of the large-scale integer linear programming solution system provided by the present invention.

[0028] Figure 10 This is a schematic diagram of the structure of the electronic device provided by the present invention. Detailed Implementation

[0029] To make the objectives, technical solutions, and advantages of this invention clearer, the technical solutions of this invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some, not all, of the embodiments of this invention. All other embodiments obtained by those skilled in the art based on the embodiments of this invention without creative effort are within the scope of protection of this invention.

[0030] It should be noted that in the description of this invention, the terms "comprising," "including," or any other variations thereof are intended to cover a non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or apparatus. Without further limitation, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, method, article, or apparatus that includes said element. The terms "upper," "lower," etc., indicating orientation or positional relationships according to the accompanying drawings, are only for the convenience of describing the invention and for simplifying the description, and do not indicate or imply that the system or element referred to must have a specific orientation, or be constructed and operated in a specific orientation, and therefore should not be construed as a limitation of the invention. Those skilled in the art can understand the specific meaning of the above terms in this invention according to the specific circumstances.

[0031] The terms "first," "second," etc., used in this invention are used to distinguish similar objects, not to describe a specific order or sequence. It should be understood that such data can be interchanged where appropriate so that embodiments of the invention can be implemented in orders other than those illustrated or described herein, and the objects distinguished by "first," "second," etc., are generally of the same class, without limiting the number of objects; for example, a first object can be one or more. Furthermore, "and / or" indicates at least one of the connected objects, and the character " / " generally indicates that the preceding and following objects are in an "or" relationship.

[0032] The following is combined Figures 1 to 10This invention describes the large-scale integer linear programming solution method, system, electronic device, storage medium, and computer program product provided by this invention.

[0033] Embodiments of this invention provide a method for solving large-scale integer linear programming problems. This method can be executed by a computer device, such as a server, personal computer, workstation, or computer cluster, or other electronic device with computing capabilities. This method aims to address the technical challenge in large-scale integer linear programming (ILP) problems where the large size of the dependent variable makes it difficult for traditional neighborhood search to balance computational efficiency and solution quality.

[0034] Figure 1 This is one of the flowcharts illustrating the large-scale integer linear programming solution method provided by this invention. For example... Figure 1 As shown, the method includes the following steps: Step 101: Based on the instance of the integer linear programming problem to be solved, construct a feasible solution pool containing multiple initial feasible solutions and determine the current solution.

[0035] In this embodiment, the first step is to receive or read an instance of an integer linear programming problem to be solved. This instance of an integer linear programming problem can typically be represented as a standard mathematical model, including decision variables ( x ), objective function coefficient vector ( c ), constraint matrix ( A ) and the right-hand vector ( b For large-scale problems, the number of decision variables can reach tens of thousands or even millions.

[0036] After obtaining the problem instance, the initialization process is initiated. The core purpose of initialization is to "cold-start" the subsequent search algorithm, that is, to first find some solutions (i.e., feasible solutions) that satisfy all constraints, providing a basic roadmap for subsequent iterations. Existing general-purpose mathematical programming solvers (such as Gurobi, SCIP, COPT, etc.) or heuristic algorithms can be used to initially solve the integer linear programming problem instance. During the initial solution process, one or more feasible solutions are collected to build a feasible solution pool containing multiple initial feasible solutions.

[0037] Meanwhile, among these initial feasible solutions, the one with the optimal objective function value (e.g., the minimum objective value for a minimization problem) is usually identified as the current solution and serves as the starting point for the first round of subsequent iterative optimization.

[0038] Step 102: Iteratively optimize the feasible solution pool and the current solution until the preset termination condition is met, and obtain the optimized target solution.

[0039] To find better solutions in a large solution space, this invention employs an iterative optimization strategy. Iterative optimization is a cyclical process that attempts to improve the current solution in each iteration. This cyclical process continues until a preset termination condition is met. This preset termination condition can be flexibly set according to the actual application scenario, such as: reaching a preset maximum number of iterations, the cumulative solution time exceeding the total time limit, or the objective function value not showing significant improvement after multiple consecutive iterations. When the termination condition is met, the algorithm stops and outputs the currently recorded optimal solution as the final optimized objective solution.

[0040] Among them, reference Figure 2 , Figure 2 This is the second flowchart illustrating the large-scale integer linear programming solution method provided by this invention. Figure 2 As shown, in each specific round of iterative optimization, the following sub-steps 1021-1024 need to be executed: Step 1021: Based on the differences between the statistical characteristics of each feasible solution in the current feasible solution pool and the current solution, determine the variable selection probability of each decision variable in the integer linear programming problem instance.

[0041] In large-scale problems, blindly and randomly selecting variables for optimization is extremely inefficient. The core of this step lies in using "historical experience" to guide the "current choice." Specifically, the feasible solution pool stores high-quality solutions found historically, which embody the statistical characteristics of the problem structure. For example, if a decision variable takes the value of 1 in most of the high-quality solutions in the solution pool, this constitutes a statistical consensus.

[0042] In this step, the statistical characteristics of each feasible solution in the current feasible solution pool (such as the distribution of variable values, consistency, etc.) are analyzed, and these statistical characteristics are compared with the values ​​of the corresponding decision variables in the current solution to calculate the differences between the two.

[0043] This difference reflects whether the value of a variable in the current solution is questionable. If the value of a variable in the current solution differs significantly from the "highly probable excellent values" statistically analyzed in the solution pool, it indicates that the variable may have taken an incorrect value, and therefore its probability of being selected should be higher so that it can be adjusted in subsequent steps. Conversely, if the difference is small, it indicates that the current value of the variable is relatively reliable, and its probability of being selected should be lower. Based on this logic, a specific variable selection probability is calculated for each decision variable, thus forming a probability distribution vector.

[0044] Step 1022: Determine the neighborhood size parameter for the current iteration based on the current solution state characteristics of the integer linear programming problem instance.

[0045] In addition to deciding which variables to choose, it is also necessary to decide how many variables to choose. For large-scale problems, choosing too few variables (too small a neighborhood) may lead to a limited search space and an inability to escape local optima; choosing too many variables (too large a neighborhood) will result in overly complex subproblems that cannot be solved in a finite amount of time.

[0046] Therefore, this step requires extracting the current solution state characteristics of the integer linear programming problem instance. These characteristics may include, but are not limited to: the static structural features of the problem (such as the number of variables and constraints), the current optimization stage, the quality of the current solution, and feedback on the difficulty of solving the problem in historical iterations. Based on these characteristics reflecting the difficulty of solving the current problem, the neighborhood size parameter for the current iteration is dynamically determined. This neighborhood size parameter is a numerical value used to indicate how many variables should be included in the optimization scope (i.e., the neighborhood size) when constructing subproblems. This dynamic adjustment mechanism ensures that the subproblems have sufficient improvement potential while remaining within a solvable complexity range.

[0047] Step 1023: Construct the subproblem for the current iteration based on the variable selection probability and neighborhood size parameter.

[0048] Next, we will combine the variable selection probability and the neighborhood size parameter to construct a specific subproblem. The specific implementation method is as follows: based on the variable selection probability of each decision variable calculated in step 1021, we will sample and select a subset of variables from all decision variables, equal in number to the neighborhood size parameter, as the variables to be optimized.

[0049] Subsequently, a smaller integer linear programming problem is constructed as a subproblem for the current iteration. During this construction, the selected variables to be optimized retain their variable properties, allowing them to change their values ​​during the solution process; while other decision variables not selected are fixed with their corresponding values ​​in the current solution, i.e., treated as constants within the subproblem. In this way, the original large-scale problem is transformed into a subproblem containing only a subset of free variables, significantly reducing its search space.

[0050] Step 1024: Call the solver to solve the subproblem, obtain a new feasible solution, and update the feasible solution pool and the current solution using the new feasible solution.

[0051] After constructing the subproblems, the mathematical programming solver is invoked to solve them within a set time. Because the size of the subproblems is controlled, the solver can usually find the optimal solution or a high-quality feasible solution, i.e., a new feasible solution, in the subspace relatively quickly.

[0052] After obtaining a new feasible solution, it needs to be evaluated to update the system state. The update operation includes two aspects: First, the current solution is updated: if the objective function value of the new feasible solution is better than the current solution, the current solution is replaced with the new feasible solution, thus improving the optimization objective.

[0053] Second, the feasible solution pool is updated: To maintain the diversity and quality of the solution pool, even if a new feasible solution is not globally optimal, as long as it has a certain quality or a structural difference from existing solutions, it can be added to the feasible solution pool to replace the poor-quality solutions in the pool. This provides fresher and higher-quality sample data for the statistical feature calculation in the subsequent iteration step 1021.

[0054] The large-scale integer linear programming solution provided in this embodiment achieves efficient solutions to large-scale problems by integrating a variable selection strategy based on solution pool statistical characteristics with a neighborhood size dynamic adjustment strategy based on solution state characteristics. On the one hand, by calculating the variable selection probability using the difference between the solution pool and the current solution, the algorithm can accurately locate the variables most likely to take incorrect values, avoiding blind searching. On the other hand, by dynamically determining the neighborhood size parameter based on the solution state, the search range is maximized while ensuring the solvability of subproblems. This hybrid strategy enables the algorithm to quickly converge to a high-quality target solution for large-scale problems with numerous variables within a limited time, significantly improving both solution efficiency and solution quality.

[0055] In one embodiment of the present invention, reference is made to... Figure 3 , Figure 3 This is the third flowchart illustrating the large-scale integer linear programming solution method provided by this invention. Figure 3 As shown, step 1021, which involves determining the variable selection probability of each decision variable in the integer linear programming problem instance based on the difference between the statistical characteristics of each feasible solution in the current feasible solution pool and the current solution, can be implemented through the following sub-steps: Step 201: Determine the ranking of each feasible solution based on the objective function value of each feasible solution in the feasible solution pool.

[0056] First, all feasible solutions in the current feasible solution pool are evaluated. Let the... In the next iteration, the feasible solution pool contains q There are one feasible solution, denoted as . For each feasible solution, obtain its corresponding objective function value. Taking a minimization problem as an example, the smaller the objective function value, the higher the quality of the solution.

[0057] Based on the objective function value, this q Sort the solutions (e.g., from smallest to largest) to determine the ranking of each feasible solution. ( j =1,..., qFor example, the solution with the smallest objective value is ranked 1, the second smallest is ranked 2, and so on. This ranking reflects the relative merit of the corresponding feasible solution within the current population.

[0058] Step 202: Based on the ranking, perform a weighted summation and normalization of the values ​​of each decision variable in each feasible solution in the feasible solution pool to obtain the confidence score of each decision variable.

[0059] After determining the ranking of each solution, a confidence score is calculated for each decision variable. This confidence score is used to characterize the likelihood or tendency of a variable to take a specific value (e.g., a value of 1) based on historical experience.

[0060] The specific calculation logic is: for the th i Each decision variable is examined to determine its value in each solution within the feasible solution pool. Then, using rankings Assign a weight to this value. Typically, the top-ranked solutions ( Smaller values ​​should have greater weight because they represent higher-quality solution structures. The weighted sum of this variable across all solutions is then normalized (e.g., divided by the largest possible weighted sum) to obtain a value between 0 and 1, which is the confidence score. The specific calculation formula is as follows: Where n is the total number of variables. The physical meaning of this confidence score is that it measures the tendency for the variable to take the value 1 (assuming it is a 0-1 integer programming problem) in a high-quality solution. The higher the score, the more likely the variable is to take the value 1 in a good solution.

[0061] For example, if a variable takes the value 1 in all the top-ranked solutions, its confidence score will approach 1; if it takes the value 0 in all solutions, the score will approach 0; if the values ​​are random, the score will be in the middle.

[0062] Step 203: Calculate the difference between the value of each decision variable in the current solution and the corresponding confidence score, and obtain the initial selection probability of each decision variable based on the difference.

[0063] At this time, in the The current solution is already available in the next iteration. (of which the first) i The values ​​of the decision variables are and the confidence score based on the solution pool statistics. Calculate the absolute value of the difference between the two, i.e. This difference has a clear physical meaning: if the value of the variable in the current solution (e.g., 1) is very close to the confidence score (e.g., 0.9, indicating a high probability of being 1), and the difference is small, it means that the value of the current variable conforms to the general consensus, and therefore it is likely correct and does not need to be modified (the probability of being selected for neighborhood re-optimization should be low). Conversely, if the value of the variable in the current solution (e.g., 1) differs greatly from the confidence score (e.g., 0.1, indicating a high probability of being 0), it means that the value of the current variable may be incorrect, and it is one of the reasons why the current solution is not good enough. Therefore, it is very likely that it needs to be modified (the probability of being selected for neighborhood re-optimization should be high).

[0064] Based on this difference and after appropriate normalization, the initial selection probability of each decision variable can be obtained. ,in, The vector of the set of confidence scores for all variables, i.e. ; It is a normalization function.

[0065] Step 204: Determine the maximum and minimum probability values ​​among all initial selection probabilities; and based on the maximum and minimum probability values, numerically correct the initial selection probabilities to obtain the variable selection probabilities.

[0066] Using the initial selection probabilities directly may result in an overly extreme probability distribution (e.g., some variables having a probability close to 0 while others are close to 1), which can cause the algorithm to converge prematurely and lose its exploration ability. To address this issue, this step introduces a numerical correction mechanism.

[0067] Specifically, the initial choice probabilities of all decision variables are first scanned to find the maximum probability value. and minimum probability value Subsequently, these two extreme values ​​are used to correct all initial selection probabilities. The purpose of this correction is to compress the range of the probability distribution, increase the chance of low-probability variables being selected, and limit the excessive monopolization of high-probability variables. The specific operation of numerical correction is used to limit the ratio between the maximum and minimum probability values ​​(e.g., controlling the maximum probability to not exceed a preset multiple of the minimum probability, such as 3 times).

[0068] The specific correction formula can be as follows: After this correction step, the final probability distribution generated is the variable selection probability. The selection probability of variables will be used for non-replacement sampling to determine which decision variables will be included in the subproblem for optimization.

[0069] In one embodiment of the present invention, reference is made to... Figure 4 , Figure 4 This is the fourth flowchart illustrating the large-scale integer linear programming solution method provided by this invention. Figure 4 As shown, step 1022, which involves determining the neighborhood size parameter for the current iteration based on the current solution state characteristics of the integer linear programming problem instance, is specifically implemented through the following sub-steps: Step 301: Model the integer linear programming problem instance as a bipartite graph, and extract the variable node features, constraint node features, and edge structure features from the bipartite graph as the solution state features.

[0070] Since integer linear programming problems typically contain two core elements—variables and constraints—in order to enable machine learning models to understand the mathematical structure of the problem, the integer linear programming problem instance to be solved is first transformed into graph structure data, specifically modeled as a "variable-constraint" bipartite graph.

[0071] In this bipartite graph, the set of nodes on one side represents the decision variables in the problem, and the set of nodes on the other side represents the constraints. If a variable appears in a constraint equation (i.e., its coefficient is non-zero), an edge is created between the corresponding variable node and the constraint node. The weight of the edge is usually the coefficient value of that variable in the constraint.

[0072] Based on the bipartite graph, multi-dimensional feature information is extracted, specifically including: Variable node characteristics can include the objective function coefficients of the variable, the value in the current solution, the upper and lower bounds of the variable, and the variable type (such as 0-1 variable or general integer variable).

[0073] Constraint node characteristics can include the right-hand side of the constraint (RHS), the constraint slack of the current solution, and the constraint type (such as the direction of the inequality).

[0074] Edge structure features: can include information such as the coefficient matrix in the constraint matrix and connection relationships.

[0075] These features together constitute the solution state characteristics at the current moment. They not only reflect the static structure of the problem, but also dynamically reflect the real-time progress of the optimization process by including information related to the current solution.

[0076] Step 302: Input the solved state features into the pre-trained reinforcement learning policy network to obtain the action distribution parameters output by the reinforcement learning policy network.

[0077] After extracting the high-dimensional solution state features, these features are used as input data and fed into a pre-trained reinforcement learning policy network.

[0078] This reinforcement learning policy network (e.g., a network built based on Graph Attention Networks, GAT, and Proximal Policy Optimization, PPO algorithms) has been trained offline on a large number of training instances. It possesses the ability to determine the appropriate action to take to adjust the solution based on the input state.

[0079] It should be noted that directly outputting a fixed neighborhood size is often not robust enough. Therefore, the policy network in this embodiment is designed to output parameters of a probability distribution, i.e., action distribution parameters. For example, the network can output the mean of a Gaussian distribution (...). μ ) and standard deviation ( σ These two parameters describe a... μ Centered on, with a fluctuation range of σ The probability distribution indicates the range of values ​​for the most suitable neighborhood size at the current moment.

[0080] Step 303: Sampling is performed based on the action distribution parameters to determine the neighborhood size parameter for the current iteration.

[0081] After obtaining the action distribution parameters, the mean is not used directly as the result. Instead, a corresponding probability distribution is constructed based on the parameters, and random sampling is performed from it.

[0082] Specifically, a Gaussian distribution is constructed based on the mean and standard deviation of the output, and an action value is sampled from it. This action value is typically a decimal between 0 and 1, representing the ratio of the neighborhood size to the total number of variables.

[0083] Finally, the sampled action value is converted into a specific integer value, for example, by multiplying the action value by the total number of variables and rounding down, thus obtaining the neighborhood size parameter for the current iteration. This neighborhood size parameter will directly guide the construction of subsequent subproblems.

[0084] In one embodiment of the present invention, reference is made to... Figure 5 , Figure 5 This is the fifth flowchart illustrating the large-scale integer linear programming solution method provided by this invention. Figure 5 As shown, the process of sampling based on action distribution parameters to determine the neighborhood size parameter of the current iteration, as described in step S303, is specifically implemented through the following sub-steps: Step 401: Construct a Gaussian distribution based on the action distribution parameters.

[0085] As mentioned earlier, the reinforcement learning policy network outputs parameters describing the probability distribution of actions, typically including the mean and variance. These two parameters are used to construct a continuous Gaussian distribution. This distribution describes the probability density of the proportion of the neighborhood that the agent believes should be selected at the current moment.

[0086] Step 402: Perform multiple samplings from the Gaussian distribution and retain the sampled values ​​within the preset interval to obtain the effective sampling results; the upper limit of the preset interval is the sum of the mean and standard deviation of the Gaussian distribution.

[0087] To avoid the randomness of sampling leading to an excessively large generated neighborhood (which would cause timeouts in solving subproblems and waste computational resources), this embodiment introduces a truncation mechanism based on statistical principles.

[0088] The specific operation is as follows: Multiple random samples are taken from the constructed Gaussian distribution. For each sampled value, it is checked whether the sampled value falls within a safe preset interval. In this embodiment, the upper limit of this preset interval is specifically set to the sum of the mean and the standard deviation, i.e. Typically, the lower limit of this preset interval can be set to 0 or a very small positive number. That is, only those that satisfy the condition are accepted. The sampling results are then processed. If a sampled value exceeds this range (e.g., falls into the long tail region of the distribution), it is discarded and resampled until a sampled value that meets the criteria is obtained, which is then determined as a valid sampling result.

[0089] Step 403: Determine the neighborhood size parameter based on the product of the effective sampling results and the total number of variables in the integer linear programming problem instance.

[0090] The effective sampling result obtained from the above steps is typically a floating-point number representing a ratio (e.g., 0.15, representing 15%). To determine the specific number of variables to select, obtain the total number of variables for the current integer linear programming problem instance. n Multiply the effective sampling results by the total number of variables (Ratio×). n The neighborhood size parameter is determined by rounding down or rounding to the nearest integer. This neighborhood size parameter will be used directly as the target number of samples without replacement in subsequent steps.

[0091] In one embodiment of the present invention, reference is made to... Figure 6 , Figure 6 This is the sixth flowchart illustrating the large-scale integer linear programming solution method provided by this invention. Figure 6 As shown, step 1023, which involves constructing the sub-problem for the current iteration based on the variable selection probability and the neighborhood size parameter, is specifically implemented through the following sub-steps: Step 501: Based on the variable selection probability, sample variables without replacement from all decision variables of the integer linear programming problem instance, with a number equal to the neighborhood size parameter, to form a set of variables to be optimized.

[0092] At this point, we have two key inputs: Variable selection probability distribution: This distribution assigns a probability value to each decision variable, with higher probabilities indicating more questionable values ​​and a greater need for adjustment. Neighborhood size parameter: This parameter is a specific integer indicating the total number of variables allowed for adjustment in this iteration.

[0093] Based on these two inputs, a weighted random sampling operation is performed. Specifically, non-replacement sampling is used, and based on the probability corresponding to each variable, samples are taken from the total... n Select from each decision variable sequentially K Each variable is unique. K The selected variables constitute the set of variables to be optimized, denoted as N. t Because probability-based sampling is used, variables with higher probability values ​​have a greater chance of being included in the set, but variables with lower probability values ​​also have a certain chance of being selected, thus balancing the targeting and exploration of the search.

[0094] Step 502: When constructing the subproblem, retain the decision variables in the set of variables to be optimized as variables, and fix the values ​​of the decision variables outside the set of variables to be optimized to the values ​​of the corresponding decision variables in the current solution.

[0095] After determining the set of variables N to be optimized t Then, we begin constructing the subproblem for the current iteration. This subproblem is essentially a restricted version of the original integer linear programming problem. The specific construction logic is as follows: For a given set N... t The decision variables remain as variables in the subproblem, and their value range (e.g., 0 or 1, or an integer range) remains consistent with the original problem. This means that the solver can freely adjust the values ​​of these decision variables to find a better solution when solving the subproblem. For those not belonging to set N... t The decision variables are forcibly fixed in value within the subproblem. The specific values ​​of these decision variables in the current solution are read and added as hard constraints to the subproblem. This means the solver cannot change the values ​​of these decision variables during the solution process.

[0096] Through the above operations, most decision variables in the original problem (usually...) n - K (The number) is fixed as a constant, with only a few KSeveral variables are involved in the optimization. This transforms a problem that was originally huge and difficult to solve directly into a smaller, easier-to-solve subproblem. The objective function of this subproblem is the same as the original problem or only contains the free variables, and the constraints are also inherited from the original problem, but some of the variables have become constants.

[0097] In one embodiment of the present invention, the process of updating the feasible solution pool and the current solution using the new feasible solution in step 1024 is specifically implemented through the following logical branches: When the solver completes the solution to the subproblem and returns a new feasible solution Then, the objective function value of the new feasible solution is first calculated. And compare it with the currently recorded global optimal solution, i.e., the current solution. objective function value Compare them.

[0098] Branch 1, Update based on the optimal operator: If the objective function value of the new feasible solution is better than that of the current solution, then the new feasible solution is updated to the new current solution, and the new feasible solution is added to the feasible solution pool.

[0099] Taking the minimization problem as an example, if This indicates that the algorithm has achieved a breakthrough in the current search direction, finding a solution better than at any point in history. At this point, perform the following operations: First, immediately submit the new feasible solution. Mark as the new current solution This ensures that the algorithm always retains the best results found so far. Then, the new feasible solution... Add to the solution pool. Because... It possesses extremely high quality and is of great reference value for guiding subsequent variable selection; therefore, it must be added to the feasible solution pool. If the solution pool is full, it will usually replace the worst or oldest solution in the pool.

[0100] Branch 2, Update based on the difference operator: If the objective function value of the new feasible solution is worse than that of the current solution, then the similarity between the new feasible solution and the existing feasible solutions in the feasible solution pool is calculated; if the similarity is lower than the preset similarity threshold, then the new feasible solution is added to the feasible solution pool.

[0101] if This indicates that while the new solution is feasible, it does not surpass the current optimal solution in terms of the objective value. However, this does not mean that the solution is worthless. Getting trapped in local optima is a common problem in large-scale optimization; preserving some solutions with significant structural differences helps the algorithm explore new regions in subsequent iterations.

[0102] Therefore, instead of discarding the solution directly, its structural value is further evaluated. The new feasible solution is then calculated. The similarity between the solution and each existing solution in the feasible solution pool. Similarity can be measured in various ways, such as calculating the Hamming distance (i.e., the number of variables with different values) or the Jaccard similarity coefficient. The specific method for calculating similarity is not limited in this embodiment.

[0103] If a new feasible solution If the similarity to all solutions in the pool is below a preset similarity threshold, it indicates that the new feasible solution represents an underexplored region in the search space. In this case, even though the objective value of the new feasible solution is not good enough, it can still be added to the feasible solution pool. When adding it, it may also be necessary to replace the solution with the smallest contribution in the pool (e.g., the most similar or the one with the worst objective value). If the new feasible solution... If the similarity with existing solutions in the pool is not lower than the preset similarity threshold, it means that the new feasible solution provides very little new information and is of poor quality, so it can be discarded.

[0104] The above implementation effectively maintains the health of the search process through a dual update criterion. The first criterion (optimal operator) ensures the convergence of the algorithm, that is, it immediately adopts any better solution found, ensuring that the optimization objective is continuously improved. The second criterion (difference operator) ensures the diversity of the algorithm. In a large-scale solution space, simply retaining high-quality solutions can easily lead to homogenization of the solution pool, resulting in the solidification of variable selection probabilities and the algorithm getting stuck in local optima. By accepting new feasible solutions whose objective values ​​are not yet good enough, this method preserves the potential for the algorithm to escape local traps and improves the robustness of global optimization.

[0105] In one embodiment of the present invention, reference is made to... Figure 7 , Figure 7 This is the seventh flowchart illustrating the large-scale integer linear programming solution method provided by this invention. Figure 7 As shown, step 101, which involves constructing a feasible solution pool containing multiple initial feasible solutions and determining the current solution based on an instance of the integer linear programming problem to be solved, is implemented through the following sub-steps: Step 601: Set the initial time limit for the solution.

[0106] Before proceeding with iterative optimization, resource consumption during the initialization phase must be limited. Excessive initialization time will encroach on subsequent neighborhood search time; insufficient initialization time may prevent the discovery of enough feasible solutions to support statistical analysis. Therefore, an initial time limit for the solution process must be set. t limit Typically, this time limit is based on the total solution time given by the user.T It is set as a certain proportion. For example, in a preferred embodiment of the present invention, the upper limit of the initial solution time is set to 20% of the total time (i.e., 0.2%). T This is a proven time allocation strategy for balancing exploration and development in large-scale problems.

[0107] Step 602: Solve the integer linear programming problem instance using the solver and start the solver callback mechanism.

[0108] A general integer programming solver (such as Gurobi, SCIP, etc.) is invoked to begin solving the original problem instance. Unlike conventional invocation, this embodiment explicitly registers and initiates a callback mechanism when invoking the solver. The callback mechanism is a technique that allows user code to interfere with the solver's internal flow. By setting a callback function, the solver's running status can be monitored. Whenever the solver finds a new integer feasible solution at a node in the branch and bound tree, or discovers a feasible point in the simplex method iteration, the solver pauses its internal flow and triggers the callback function, briefly returning control to the user program.

[0109] Step 603: When the solver callback mechanism detects that the number of feasible solutions generated by the solver has reached a preset threshold, or the solution time has reached the time limit, the initial solution process is terminated.

[0110] During the solver's operation, the user program monitors two key metrics in real time via a callback mechanism: the number of feasible solutions and the running time. The number of feasible solutions refers to the number of distinct feasible solutions found so far, as recorded by a counter. A preset threshold (e.g., 2 or 5) is used. Once the number of solutions found reaches this threshold, it indicates that there are enough samples to initiate subsequent statistical analysis. The running time refers to how long the solver has been running, as recorded by a timer.

[0111] The termination condition is an OR operation between the two conditions mentioned above: If the solver is very efficient and finds a sufficient number (e.g., 2) of feasible solutions in a short time, in order to save time, a termination command is immediately sent through a callback function to forcibly stop the solver's operation.

[0112] If the problem is very difficult and the solver reaches the set time limit, it must be forcibly stopped even if only one solution is found or even if not enough solutions are found, to prevent the initialization phase from consuming time indefinitely.

[0113] Step 604: Collect all feasible solutions generated in the initial solution phase to construct a feasible solution pool, and determine the solution with the optimal objective function value in the feasible solution pool as the current solution.

[0114] After the initial solution process terminates, all feasible solutions discovered during this stage are retrieved from the solver's internal storage or callback function records. These solutions constitute the initial feasible solution pool. The quality of the solution pool directly determines the accuracy of variable selection probabilities in the subsequent first iteration. Then, all solutions in the solution pool are traversed, their objective function values ​​are compared, and the best one (e.g., the solution with the smallest objective value) is selected and marked as the current solution. This current solution will serve as the starting point for iterative optimization of the algorithm.

[0115] Reference Figure 8 , Figure 8 This is a flowchart illustrating the overall framework for solving large-scale integer linear programming problems provided by this invention. The following is a combination of... Figure 8 The overall technical solution provided by the embodiments of this application will be described in detail below, along with the above embodiments.

[0116] like Figure 8 As shown, the large-scale integer linear programming solution framework provided in this application mainly consists of several core stages: 1. Problem modeling and feature extraction stage; 2. First step: initialization stage; 3. Second step: neighborhood generation stage; and 4. Third step: iterative optimization stage. These four stages will be explained in detail below.

[0117] 1. Problem modeling and feature extraction stage: First, the system receives an instance of an integer programming problem to be solved. The mathematical form of this problem is: To enable computers (especially reinforcement learning models) to understand the structure of the problem, the system models the algebraic problem as a bipartite graph. For example... Figure 8 As shown on the left, the bipartite graph contains two types of nodes: the variable nodes at the top. and the constraint nodes below The connection between a variable and a constraint indicates that the variable participates in the constraint equation. Based on this bipartite graph, the system performs feature extraction, which includes: variable node features V, containing dynamic and static features (such as coefficients and the current solution state); constraint node features C; and edge structure features E, representing the connection relationship between variables and constraints. These features together constitute the current solution state, serving as the input for subsequent agent decisions.

[0118] 2. Step 1: Initialization Phase like Figure 8As shown below, to quickly initiate the search process, this embodiment introduces a callback mechanism in the early stages of the solution process. The system calls a general solver (such as Gurobi or SCIP) to perform an initial solution to the original problem. To avoid the lengthy waiting times found in traditional methods, the system sets a time limit (e.g., 0.2 seconds). T ,in T (This is the total time budget). During this process, the callback mechanism monitors the solver status in real time. Once the solver produces a feasible solution, the system collects and stores it in the solution pool via the `store solutions` operation. In the meantime, the system marks the optimal solution found during the initialization phase as the initial current solution. This step ensures that the algorithm has a sufficiently diverse set of "seed" solutions before entering the reinforcement learning iteration.

[0119] 3. Second step: Neighborhood generation stage: This is the core step of the invention, employing a "dual-track" strategy to determine the sub-problems: Path 1 (rule-based variable probability calculation): as follows Figure 8 As shown in the middle, the system utilizes a solution pool. Calculating the probability of historical solutions To prevent probability polarization, the system introduces the RC operator (Range Control Operator) to smooth the calculated probabilities, limiting the ratio of the maximum to the minimum probability, thereby obtaining the probability distribution of the variable being selected. Path Two (Agent-Based Size Prediction): The system inputs the graph features extracted from the left side into the agent. The agent outputs the action distribution for the current state. To avoid extreme cases, the system introduces the TDR operator (Tail Distribution Removal) to truncate and sample the output distribution, thereby determining the specific action. That is, the neighborhood size (how many variables to select). Ultimately, in the variable selection module, the system combines probability... and scale The set of variables to be optimized in the current iteration is obtained by sampling. Figure 8 (The nodes are displayed in pink).

[0120] 4. Third step: Iterative optimization phase: Specifically, each round of iterative optimization can be carried out through the following three steps: Subproblem construction: At this point, for the unselected variables ( () is forcibly fixed as the current solution The value is retained only for the selected variable. )be free.

[0121] Subproblem solving: The system calls the solver again to solve this smaller subproblem, with a time budget of 0.1. T .

[0122] Solution update and evaluation: Local new solutions obtained from the solution. It requires two rounds of judgment: first, it is judged by the optimal operator. Is it better than the global optimum? If yes, then update the global optimum. (Diversity Operator): If not optimal, then further determine using the difference operator. With the solution pool The difference between existing solutions is considered. If the difference meets the preset similarity threshold (yes), it is added to the solution pool. In order to maintain population diversity.

[0123] The second step, neighborhood generation, and the third step, iterative optimization, will be executed continuously in a loop until the preset termination condition is met, thereby achieving efficient and automatic search and solution for large-scale integer linear programming problems.

[0124] Reference Figure 9 , Figure 9 This is a schematic diagram of the structure of the large-scale integer linear programming solution system provided by the present invention. The system includes: The first processing module is used to construct a feasible solution pool containing multiple initial feasible solutions and determine the current solution based on the instance of the integer linear programming problem to be solved; The second processing module is used to iteratively optimize the feasible solution pool and the current solution until a preset termination condition is met to obtain the optimized target solution. In each round of iterative optimization, the following steps are performed: based on the difference between the statistical characteristics of each feasible solution in the current feasible solution pool and the current solution, the variable selection probability of each decision variable in the integer linear programming problem instance is determined; based on the current solution state characteristics of the integer linear programming problem instance, the neighborhood size parameter of the current iteration is determined; based on the variable selection probability and the neighborhood size parameter, a subproblem of the current iteration is constructed; the solver is invoked to solve the subproblem to obtain a new feasible solution, and the feasible solution pool and the current solution are updated using the new feasible solution.

[0125] It should be noted that the large-scale integer linear programming solution system provided by the present invention can execute the large-scale integer linear programming solution method of any of the above embodiments during specific operation, which will not be elaborated in this embodiment.

[0126] Figure 10 This is a schematic diagram of the structure of the electronic device provided by the present invention, such as... Figure 10As shown, the electronic device may include a processor 1010, a communication interface 1020, a memory 1030, and a communication bus 1040, wherein the processor 1010, the communication interface 1020, and the memory 1030 communicate with each other through the communication bus 1040. The processor 1010 can call logical instructions in the memory 1030 to execute the large-scale integer linear programming solution methods provided in the above embodiments.

[0127] Furthermore, the logical instructions in the aforementioned memory 1030 can be implemented as software functional units and, when sold or used as independent products, can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of the present invention, or the part that contributes to the prior art, or a part of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute all or part of the steps of the methods of the various embodiments of the present invention. The aforementioned storage medium includes various media capable of storing program code, such as USB flash drives, portable hard drives, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks.

[0128] On the other hand, the present invention also provides a computer program product, which includes a computer program stored on a non-transitory computer-readable storage medium. The computer program includes program instructions, and when the program instructions are executed by a computer, the computer is able to execute the large-scale integer linear programming solution method provided in the above embodiments.

[0129] In another aspect, the present invention also provides a non-transitory computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, is implemented to perform the large-scale integer linear programming solution methods provided in the above embodiments.

[0130] The system embodiments described above are merely illustrative. The units described as separate components may or may not be physically separate, and the components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the modules can be selected to achieve the purpose of this embodiment according to actual needs. Those skilled in the art can understand and implement this without any creative effort.

[0131] Through the above description of the embodiments, those skilled in the art can clearly understand that each embodiment can be implemented by means of software plus necessary general-purpose hardware platforms, and of course, it can also be implemented by hardware. Based on this understanding, the above technical solutions, in essence or the part that contributes to the prior art, can be embodied in the form of a software product. This computer software product can be stored in a computer-readable storage medium, such as ROM / RAM, magnetic disk, optical disk, etc., including several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute the methods of various embodiments or some parts of embodiments.

[0132] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention, and not to limit them; although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features; and these modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of the present invention.

Claims

1. A method for solving large-scale integer linear programming problems, characterized in that, include: Based on the instance of the integer linear programming problem to be solved, construct a feasible solution pool containing multiple initial feasible solutions and determine the current solution; The feasible solution pool and the current solution are iteratively optimized until a preset termination condition is met, and the optimized target solution is obtained. In each round of iterative optimization, the following steps are performed: Based on the difference between the statistical characteristics of each feasible solution in the current feasible solution pool and the current solution, the variable selection probability of each decision variable in the integer linear programming problem instance is determined; Based on the current solution state characteristics of the integer linear programming problem instance, determine the neighborhood size parameter for the current iteration; Based on the variable selection probability and the neighborhood size parameter, construct the sub-problem for the current iteration; The solver is invoked to solve the subproblem, a new feasible solution is obtained, and the feasible solution pool and the current solution are updated using the new feasible solution.

2. The method for solving large-scale integer linear programming according to claim 1, characterized in that, The determination of the variable selection probability of each decision variable in the integer linear programming problem instance based on the difference between the statistical characteristics of each feasible solution in the current feasible solution pool and the current solution includes: The ranking of each feasible solution is determined based on the objective function value of each feasible solution in the feasible solution pool; Based on the ranking, the values ​​of each decision variable in each feasible solution in the feasible solution pool are weighted, summed, and normalized to obtain the confidence score of each decision variable; Calculate the difference between the value of each decision variable in the current solution and the corresponding confidence score, and obtain the initial selection probability of each decision variable based on the difference; Determine the maximum and minimum probability values ​​among all the initial selection probabilities; The initial selection probability is numerically corrected based on the maximum probability value and the minimum probability value to obtain the variable selection probability; the numerical correction is used to limit the ratio between the maximum probability value and the minimum probability value.

3. The method for solving large-scale integer linear programming according to claim 1, characterized in that, The step of determining the neighborhood size parameter for the current iteration based on the current solution state characteristics of the integer linear programming problem instance includes: The integer linear programming problem instance is modeled as a bipartite graph, and the variable node features, constraint node features, and edge structure features in the bipartite graph are extracted as the solution state features. The solved state features are input into a pre-trained reinforcement learning policy network to obtain the action distribution parameters output by the reinforcement learning policy network. Based on the action distribution parameters, the neighborhood size parameter of the current iteration is determined by sampling.

4. The method for solving large-scale integer linear programming according to claim 3, characterized in that, The step of sampling based on the action distribution parameters to determine the neighborhood size parameter for the current iteration includes: Construct a Gaussian distribution based on the action distribution parameters; Multiple samples are taken from the Gaussian distribution, and the sampled values ​​within a preset interval are retained to obtain valid sampling results; the upper limit of the preset interval is the sum of the mean and standard deviation of the Gaussian distribution; The neighborhood size parameter is determined by multiplying the effective sampling results by the total number of variables in the integer linear programming problem instance.

5. The method for solving large-scale integer linear programming according to claim 1, characterized in that, The step of constructing the sub-problem for the current iteration based on the variable selection probability and the neighborhood size parameter includes: Based on the variable selection probability, variables equal to the neighborhood size parameter are sampled non-replaced from all decision variables of the integer linear programming problem instance to form a set of variables to be optimized. When constructing the subproblem, the decision variables in the set of variables to be optimized are retained as variables, and the values ​​of the decision variables outside the set of variables to be optimized are fixed to the values ​​of the corresponding decision variables in the current solution.

6. The method for solving large-scale integer linear programming according to claim 1, characterized in that, The step of updating the feasible solution pool and the current solution using the new feasible solution includes: If the objective function value of the new feasible solution is better than the objective function value of the current solution, then the new feasible solution is updated to the new current solution, and the new feasible solution is added to the feasible solution pool; If the objective function value of the new feasible solution is worse than that of the current solution, then the similarity between the new feasible solution and the existing feasible solutions in the feasible solution pool is calculated. If the similarity is lower than a preset similarity threshold, the new feasible solution is added to the feasible solution pool.

7. The method for solving large-scale integer linear programming according to claim 1, characterized in that, The step of constructing a feasible solution pool containing multiple initial feasible solutions and determining the current solution based on an instance of the integer linear programming problem to be solved includes: Set an initial time limit for the solution; The solver is used to solve the integer linear programming problem instance, and the solver callback mechanism is activated. When the solver callback mechanism detects that the number of feasible solutions generated by the solver reaches a preset threshold, or the solution time reaches the time limit, the initial solution process is terminated. All feasible solutions generated in the initial solution phase are collected to construct the feasible solution pool, and the solution with the optimal objective function value in the feasible solution pool is determined as the current solution.

8. A large-scale integer linear programming solution system, characterized in that, include: The first processing module is used to construct a feasible solution pool containing multiple initial feasible solutions and determine the current solution based on the instance of the integer linear programming problem to be solved; The second processing module is used to iteratively optimize the feasible solution pool and the current solution until a preset termination condition is met to obtain the optimized target solution. In each round of iterative optimization, the following steps are performed: based on the difference between the statistical characteristics of each feasible solution in the current feasible solution pool and the current solution, the variable selection probability of each decision variable in the integer linear programming problem instance is determined; based on the current solution state characteristics of the integer linear programming problem instance, the neighborhood size parameter of the current iteration is determined; based on the variable selection probability and the neighborhood size parameter, a subproblem of the current iteration is constructed; the solver is invoked to solve the subproblem to obtain a new feasible solution, and the feasible solution pool and the current solution are updated using the new feasible solution.

9. An electronic device comprising a memory, a processor, and a computer program stored in the memory and running on the processor, characterized in that, When the processor executes the computer program, it implements the large-scale integer linear programming solution method as described in any one of claims 1 to 7.

10. A non-transitory computer-readable storage medium having a computer program stored thereon, characterized in that, When the computer program is executed by the processor, it implements the large-scale integer linear programming solution method as described in any one of claims 1 to 7.

Images