A learning optimization method and system for solving a quadratic programming problem

Abstract

This invention discloses a learning optimization method and system for solving quadratic programming problems, relating to the intersection of mathematical optimization and artificial intelligence. The method includes: inputting convex quadratic programming parameters, transforming them into a two-block separable form through auxiliary variables and indicator functions; initializing variables and LSTM states; generating iterative approximate solutions using LSTM, and determining whether sufficient descent and gradient conditions are met, triggering a gradient descent guarantee mechanism if these conditions are not satisfied; updating auxiliary variables element-wise, adaptively updating relaxation and penalty parameters, and outputting the original and dual solutions; and training the LSTM offline using identically distributed samples. This invention combines the fast inference of neural networks with the convergence guarantee of traditional algorithms, offering high real-time performance, strong robustness, and low resource consumption. It is suitable for scenarios such as high-frequency trading, autonomous driving, edge AI, and power grid scheduling, efficiently solving dynamic parameter convex quadratic programming problems.

Description

Technical Field

[0001] This invention belongs to the interdisciplinary field of mathematical optimization and artificial intelligence, specifically relating to a learning optimization method and system for solving quadratic programming problems. Background Technology

[0002] Convex quadratic programming (QP) is one of the core problems in the field of mathematical optimization. Its goal is to minimize a convex quadratic function under a set of linear constraints. Due to its excellent mathematical properties and strong modeling capabilities, convex quadratic programming has become a fundamental mathematical tool in many fields such as engineering, finance, artificial intelligence, energy, and robotics. It is widely used in key technical scenarios such as portfolio optimization, model predictive control, support vector machine training, and optimal power flow calculation.

[0003] Currently, the techniques for solving convex quadratic programming problems are mainly divided into two categories: traditional numerical optimization algorithms and deep learning-based learning optimization methods.

[0004] Traditional numerical optimization algorithms include interior-point methods, active-set methods, alternating-direction multiplier methods (ADMM), and commercial solvers such as OSQP. These algorithms offer strict theoretical convergence guarantees and high solution accuracy, but they suffer from the following significant technical drawbacks: Poor real-time performance and inability to handle dynamic parameter scenarios: When problem parameters (such as quadratic matrices, linear term coefficients, and constraint boundaries) change dynamically, traditional algorithms need to perform expensive matrix decomposition or a complete numerical iteration process, resulting in significant computational latency. For example, in high-frequency trading scenarios, market conditions can change thousands of times per second, and the computational latency of traditional algorithms can lead to missed optimal trading opportunities. In model predictive control for autonomous driving, the control cycle is typically on the order of milliseconds, and the computational time of traditional solvers often becomes a bottleneck for control frequency, potentially causing system response lag or even instability.

[0005] High computational complexity makes it difficult to deploy on resource-constrained devices: For large-scale convex quadratic programming problems (such as training machine learning models with millions of data points and calculating optimal power flow in large-scale power grids), the memory consumption and computational load of traditional algorithms increase exponentially, making them unsuitable for deployment on resource-constrained devices such as smartphones and edge sensors, thus limiting the development of edge intelligence and distributed optimization.

[0006] Poor parameter adaptability and unstable convergence speed: The penalty and relaxation parameters of traditional algorithms such as ADMM are mostly manually preset, which cannot be adaptively adjusted according to the specific form of the problem and the instantaneous state during the iteration process. For convex quadratic programming problems with different structures, a lot of time is required for parameter tuning, and the convergence speed fluctuates greatly, making it difficult to balance convergence speed and algorithm stability.

[0007] Deep learning-based optimization methods are a novel solution technique that has emerged in recent years. They significantly improve solution speed by learning the iterative rules of optimization algorithms through neural networks. However, these methods suffer from the following fatal flaws: Lacking theoretical convergence guarantees, the accuracy of the solution is uncontrollable: Pure neural network methods learn the solution process solely through data-driven methods, failing to theoretically guarantee the convergence and optimality of the solution. In practical applications, neural networks may output invalid solutions that do not meet constraints or accuracy requirements, making them unsuitable for industrial scenarios with extremely high reliability requirements.

[0008] Insufficient robustness and lack of safety mechanisms: When the input data is abnormal or the problem distribution shifts, the predictive performance of the neural network drops sharply, even producing completely wrong results. Due to the lack of reliable fault protection mechanisms, this type of method cannot meet the application requirements of safety-critical fields such as autonomous driving and power grid dispatching.

[0009] In summary, existing convex quadratic programming solution techniques cannot simultaneously meet the requirements of real-time performance, accuracy guarantee, robustness, and resource friendliness, severely restricting the application of convex quadratic programming in dynamic, large-scale, and safety-critical scenarios. Therefore, there is an urgent need to develop a novel convex quadratic programming solution method that combines high efficiency, reliability, and adaptability. Summary of the Invention

[0010] The technical problem to be solved by this invention is to provide a learning optimization method and system for solving quadratic programming problems, which addresses the shortcomings of the prior art. This method solves the problems of large computational delay and poor real-time performance in scenarios with dynamic parameter changes in existing convex quadratic programming algorithms, the inability of traditional numerical algorithms and pure neural network methods to balance solution efficiency and theoretical convergence guarantee, and the difficulty of efficiently deploying both types of algorithms in resource-constrained environments.

[0011] The present invention adopts the following technical solution: A learning optimization method for solving quadratic programming problems includes the following steps: Input the parameters of the convex quadratic programming problem to be solved, which include the quadratic matrix, linear term coefficients, constraint matrix, lower bound vector, and upper bound vector; By introducing auxiliary variables, the convex quadratic programming problem is equivalently transformed into an optimization problem with equality constraints and boundary constraints. Furthermore, by introducing the characteristic function of the boundary constraints, the transformed optimization problem is rewritten into a two-block separable form suitable for iterative updates using the alternating direction multiplier method. Initialize the original variables, auxiliary variables, dual variables, and the hidden states and memory unit states of the long short-term memory network; In each iteration, the approximate solution and its gradient from the previous time step are input into the Long Short-Term Memory (LSTM) network, and the LSM network is used to output the approximate solution of the subproblem in the current iteration. Determine whether the approximate solution to the subproblem simultaneously satisfies the preset sufficient descent condition and gradient condition; when the approximate solution to the subproblem does not satisfy the sufficient descent condition and the gradient condition, perform gradient descent for the corresponding subproblem for a preset number of steps to obtain an approximate solution that satisfies the sufficient descent condition and the gradient condition; Based on the approximate solution that satisfies the sufficient descent condition and the gradient condition, the auxiliary variable is updated by element-wise projection, and the dual variable is updated according to the updated original variable, auxiliary variable and penalty parameter; The relaxation parameters are learned adaptively, and the penalty parameters are updated adaptively based on the learnable scalar and the Lipschitz constant of the objective function. The original solution and dual solution obtained after a preset number of iterations are output as the solution results of the convex quadratic programming problem.

[0012] Preferably, before solving the convex quadratic programming problem, a set of identically distributed convex quadratic programming problem samples are collected or simulated from the target application scenario. Each sample includes at least a quadratic matrix, linear term coefficients, constraint matrix, lower bound vector, and upper bound vector, and the samples are used to form a training dataset for training the parameters of the long short-term memory network.

[0013] Preferably, after the convex quadratic programming problem is equivalently transformed into an optimization problem with equality constraints and boundary constraints, the optimization problem is rewritten into a two-part separable form in which the objective function consists of a smooth quadratic term and a non-smooth indicator term by introducing an indicator function of the boundary constraints.

[0014] Preferably, in each iteration, the long short-term memory network unit receives the approximate solution and its gradient from the previous time step as input, calculates the update direction through the input gate, forget gate and output gate, and outputs the approximate solution of the subproblem in the current iteration, and the parameters of the long short-term memory network unit are shared in each iteration.

[0015] Preferably, it is determined whether the approximate solution of the subproblem satisfies a preset imprecision condition. The imprecision condition includes at least a sufficient descent condition and a gradient condition. The approximate solution of the subproblem is accepted for subsequent variable updates only when the approximate solution of the subproblem satisfies both the sufficient descent condition and the gradient condition.

[0016] Preferably, when the approximate solution to the subproblem does not satisfy the sufficient descent condition and the gradient condition, gradient descent with a preset step size and a preset number of steps is performed on the corresponding subproblem to obtain an approximate solution that satisfies the sufficient descent condition and the gradient condition.

[0017] Preferably, when updating the auxiliary variable, the updated value of the auxiliary variable is obtained through an element-wise projection operation; when updating the dual variable, the dual variable is updated based on the updated original variable, auxiliary variable, and penalty parameter.

[0018] Preferably, a line search is performed on the relaxation parameters, and the relaxation parameters are updated through a learnable adaptive parameter adjustment mechanism.

[0019] Preferably, the penalty parameters are adaptively updated based on the learnable scalar and the Lipschitz constant of the objective function of the convex quadratic programming problem, and the penalty parameter update adopts the Sigmoid transformation; furthermore, the trainable parameters of the long short-term memory network are trained offline using the truncated time backpropagation method and a self-supervised loss function.

[0020] Secondly, embodiments of the present invention provide a learning optimization system for solving quadratic programming problems, comprising: The parameter input and problem transformation module is used to input the parameters of the convex quadratic programming problem to be solved, and to transform the convex quadratic programming problem into a two-block separable form suitable for iterative updates using the alternating direction multiplier method; An approximate solution generation module, connected to the parameter input and problem transformation module, is used to generate approximate solutions to sub-problems for each iteration based on a long short-term memory network. The condition judgment and guarantee module, connected to the approximate solution generation module, is used to judge whether the approximate solution of the subproblem satisfies the sufficient descent condition and the gradient condition, and to perform gradient descent to obtain an approximate solution that satisfies the conditions if the conditions are not met. The variable and parameter update module, connected to the condition judgment and guarantee module, is used to update auxiliary variables, dual variables, relaxation parameters and penalty parameters, and output the original solution and dual solution of the convex quadratic programming problem.

[0021] Thirdly, a computer device includes a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor, when executing the computer program, implements the steps of the learning optimization method described above for solving quadratic programming problems.

[0022] Fourthly, embodiments of the present invention provide a computer-readable storage medium including a computer program, which, when executed by a processor, implements the steps of the learning optimization method described above for solving quadratic programming problems.

[0023] Fifthly, a chip includes a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor, when executing the computer program, implements the steps of the learning optimization method described above for solving quadratic programming problems.

[0024] In a sixth aspect, embodiments of the present invention provide an electronic device including a computer program, which, when executed by the electronic device, implements the steps of the learning optimization method described above for solving quadratic programming problems.

[0025] Compared with the prior art, the present invention has at least the following beneficial effects: A learning-optimization method for solving quadratic programming problems transforms the original convex quadratic programming problem into a two-block separable form by introducing auxiliary variables and indicator functions, laying the foundation for distributed computing. Secondly, it utilizes an LSTM network to directly generate approximate solutions to subproblems in each iteration, replacing the time-consuming exact solution process in traditional ADMM, significantly reducing the computational complexity of a single iteration. The learning + optimization architecture allows the algorithm to leverage historical solution experience, eliminating the need for expensive matrix factorization when dealing with dynamically changing identically distributed problems, thus significantly improving solution speed. This makes it particularly suitable for scenarios with extremely high real-time requirements, such as high-frequency trading and model predictive control.

[0026] Furthermore, identically distributed convex quadratic programming samples from the target scenario are collected or simulated to cover parameter variations and constraint differences, ensuring that the training data matches the actual problem being solved. Self-supervised loss and truncated time backpropagation are used for training, eliminating the need for manual annotation and reducing data costs. After offline training, only forward propagation is required during the inference phase to output a high-quality approximate solution, significantly reducing the frequency of safety guard triggers. This allows the LSTM to learn the scenario optimization rules in advance, avoiding repeated training during the inference phase, improving its adaptability to dynamic parameters and constraint changes, ensuring rapid response in identically distributed, repeatedly solved scenarios such as high-frequency trading and autonomous driving, while maintaining solution consistency and stability, reducing online computational overhead and parameter tuning costs.

[0027] Furthermore, the original problem is transformed into an equation plus boundary constraints, and then decomposed into a two-part separable structure of smooth quadratic terms and non-smooth characteristic terms using indicator functions. This adapts to the ADMM iteration rules, achieving decoupled variable updates and avoiding complex coupled calculations. Smooth terms can be efficiently differentiated, and non-smooth terms can be solved using projection closed-form, significantly reducing the computational cost per iteration. The separable structure facilitates embedding into neural networks for approximate prediction, while retaining the interpretability and convergence of traditional numerical iteration. This transformation addresses the difficulty of directly solving the original problem efficiently using ADMM, improving iteration efficiency and numerical stability, enabling LSTM to accurately learn the update patterns of subproblems, balancing the speed of learning optimization with the rigor of numerical optimization, and adapting to large-scale and high-constraint-density problems.

[0028] Furthermore, by encoding the iterative temporal dependencies through input gates, forget gates, and output gates, the update direction is accurately predicted. Parameters are shared throughout the entire iteration, reducing the number of parameters and computational overhead, and avoiding overfitting. The LSTM memory unit retains the historical iteration state, simulating the behavior of a first-order optimization algorithm. Historical information is used to accelerate the convergence of the current iteration, enabling the network to capture the temporal patterns of the optimization process. This is more intelligent and efficient than fixed-format iteration, approaching the optimal solution within a small number of iterations. The lightweight parameters are suitable for deployment on edge devices, and the gating mechanism stabilizes information flow, alleviates gradient oscillations, and improves the generalization ability to different problem scales, achieving a balance between rapid iteration and high-precision output.

[0029] Furthermore, a dual inaccuracy criterion of sufficient descent and gradient conditions is established as the basis for accepting approximate solutions. The simultaneous satisfaction of these two conditions ensures that the solution meets the standards in terms of objective function descent and gradient accuracy, avoiding invalid iterations. Clearly defined criteria provide theoretical convergence support for the algorithm, distinguishing it from pure black-box neural networks. Only qualified solutions are accepted for subsequent updates, ensuring that iterations progress towards the optimal direction. This mechanism achieves controllable inaccuracy, allowing for rapid approximation while maintaining accuracy, thus balancing speed and precision.

[0030] Furthermore, when the approximate solution does not meet the conditions, a fixed-step gradient descent with a fixed number of steps is executed to obtain a qualified solution, forming a safety guard mechanism. The preset step size and number of steps ensure predictable computation and controllable time consumption; gradient descent, a classic stable optimization method, ensures that the output solution always meets the convergence condition; it is only activated during the inference phase, without interfering with offline training, thus ensuring training efficiency. This forms a learning-centric architecture with a safety net, ensuring that even when the neural network predicts a deviation, it can still output a qualified solution, completely eliminating the risk of solution failure; it maintains algorithm stability and improves robustness under abnormal inputs and distribution shifts.

[0031] Furthermore, the auxiliary variables are updated using element-wise projection in a closed-form manner, which is computationally extremely fast and has no iteration overhead. The dual variables are updated based on the original variables, auxiliary variables, and penalty parameters, driving the equality constraints to be satisfied step by step. The closed-form solution avoids numerical iteration, reducing single-step time consumption; the dual update ensures consistency between the original and auxiliary variables, improving constraint satisfaction. It is suitable for scenarios with high real-time requirements, significantly improving the solution speed while maintaining accuracy, enabling the algorithm to complete iterations within milliseconds, making it suitable for high-frequency control scenarios such as model predictive control.

[0032] Furthermore, an adaptive adjustment mechanism selects the optimal step size, avoiding manual parameter tuning; a learnable mechanism dynamically adjusts based on the iteration state, balancing convergence speed and numerical stability. This addresses the problems of traditional ADMM relaxation parameters relying on human experience and unstable convergence, automatically adapting to different problem structures and parameter changes, reducing parameter tuning costs, improving the algorithm's versatility and robustness, and maintaining stable and rapid convergence in large-scale problems and dynamic scenarios.

[0033] Furthermore, updates are based on learnable scalars and the Lipschitz constant, and the Sigmoid transformation is used to mitigate gradient explosion / vanishing. The LSTM employs truncated time backpropagation and self-supervised loss for offline training. The adaptive penalty parameter is dynamically adjusted according to the constraint activity level to improve problem adaptability; the Sigmoid transformation ensures smooth and stable updates; and offline training makes the inference phase more efficient.

[0034] It is understood that the beneficial effects of the second to sixth aspects mentioned above can be found in the relevant descriptions in the first aspect mentioned above, and will not be repeated here.

[0035] In summary, this invention constructs a solver that combines the speed of neural networks with the accuracy of numerical algorithms by integrating LSTM and I-ADMM. It accelerates iteration using data-driven approaches, ensures convergence through a guarantee mechanism, and enhances robustness by combining adaptive parameter adjustment. It perfectly resolves the contradiction between the poor real-time performance of traditional algorithms and the lack of theoretical guarantees in pure learning methods, and achieves efficient, safe, and adaptive convex quadratic programming solutions, which are particularly suitable for dynamic parameter scenarios and edge computing deployments.

[0036] The technical solution of the present invention will be further described in detail below with reference to the accompanying drawings and embodiments. Attached Figure Description

[0037] Figure 1 This is a flowchart of the method of the present invention; Figure 2 This is a schematic diagram of the unit structure and information transmission of a Long Short-Term Memory (LSTM) network; Figure 3 A schematic diagram of a computer device provided in an embodiment of the present invention; Figure 4 This is a block diagram of a chip provided according to an embodiment of the present invention.

[0038] Among them, 60. Computer equipment; 61. Processor; 62. Memory; 63. Computer program; 600. Electronic device; 610. Processing unit; 620. Storage unit; 6201. Random access memory unit; 6202. Cache memory unit; 6203. Read-only memory unit; 6204. Program / utility; 6205. Program module; 630. Bus; 640. Display unit; 650. Input / output interface; 660. Network adapter; 700. External device. Detailed Implementation

[0039] 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, not all, of the embodiments of the present invention. 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.

[0040] In the description of this invention, it should be understood that the terms "comprising" and "including" indicate the presence of the described features, integrals, steps, operations, elements and / or components, but do not exclude the presence or addition of one or more other features, integrals, steps, operations, elements, components and / or collections thereof.

[0041] It should also be understood that the terminology used in this specification is for the purpose of describing particular embodiments only and is not intended to limit the invention. As used in this specification and the appended claims, the singular forms “a,” “an,” and “the” are intended to include the plural forms unless the context clearly indicates otherwise.

[0042] It should also be further understood that the term "and / or" as used in this specification and the appended claims refers to any combination and all possible combinations of one or more of the associated listed items, and includes such combinations. For example, A and / or B can represent three cases: A alone, A and B simultaneously, and B alone. Additionally, the character " / " in this invention generally indicates that the preceding and following objects have an "or" relationship.

[0043] It should be understood that although terms such as first, second, third, etc., may be used in the embodiments of the present invention to describe the preset range, these preset ranges should not be limited to these terms. These terms are only used to distinguish the preset ranges from one another. For example, without departing from the scope of the embodiments of the present invention, the first preset range may also be referred to as the second preset range, and similarly, the second preset range may also be referred to as the first preset range.

[0044] Depending on the context, the word "if" as used here can be interpreted as "when," "when," "in response to determination," or "in response to detection." Similarly, depending on the context, the phrase "if determination" or "if detection (of the stated condition or event)" can be interpreted as "when determination," "in response to determination," "when detection (of the stated condition or event)," or "in response to detection (of the stated condition or event)."

[0045] The accompanying drawings illustrate various structural schematic diagrams according to embodiments disclosed in this invention. These drawings are not to scale, and some details have been enlarged for clarity, and some details may have been omitted. The shapes of the various regions and layers shown in the drawings, as well as their relative sizes and positional relationships, are merely exemplary and may deviate from reality due to manufacturing tolerances or technical limitations. Furthermore, those skilled in the art can design regions / layers with different shapes, sizes, and relative positions as needed.

[0046] This invention provides a learning optimization method for solving quadratic programming problems. It embeds LSTM into ADMM iteration to learn and optimize temporal patterns, reducing the number of iterations. It constructs a dual-judgment system of sufficient descent and gradient conditions to achieve controllable, inaccurate solutions. A gradient descent safetyguard mechanism is implemented to guarantee a qualified solution. Relaxation and penalty parameters are adaptively updated, replacing manual parameter tuning. Offline self-supervised training with identically distributed samples improves inference speed and stability. Closed projection updates variables, reducing computational complexity. This significantly improves the solution speed for dynamic parameter scenarios, meeting millisecond-level real-time requirements. It has theoretical convergence guarantees, ensuring reliable and safe solutions. It requires no manual parameter tuning and exhibits strong generalization. It has low computational resource consumption, allowing deployment on edge devices. It is highly robust, remaining unaffected by abnormal inputs, and is suitable for safety-critical and real-time-critical scenarios such as finance, control, power grids, and machine learning.

[0047] Please see Figure 1 This invention discloses a learning optimization method for solving quadratic programming problems, comprising the following steps: S1. Generate training dataset Collect or simulate a set of identically distributed convex quadratic programming problem samples from the target application scenario. Each sample contains complete parameters: a quadratic matrix. Linear term coefficients constraint matrix Lower bound vector and upper bound vector These samples constitute the training dataset. This is used for training the parameters of the subsequent neural network.

[0048] S2, Input the original problem parameters Input parameters for the convex quadratic programming problem to be solved: quadratic matrix Linear term coefficients constraint matrix Lower bound vector and upper bound vector These parameters constitute the specific problem that needs to be solved:

[0049] S3. Introduce auxiliary variables to perform equivalent transformation of the problem. Introducing auxiliary variables The original problem is equivalently transformed into a form with equality constraints and boundary constraints:

[0050] This transformation makes the problem applicable to the alternating direction multiplier method framework and enables the adjustment of variables. Efficient projection updates.

[0051] S4. Introduce characteristic functions and rewrite the form into a two-block separable form. Indicator function with introduced boundary constraints The problem can be rewritten as an optimization problem that can be separated into two blocks:

[0052] This form decomposes the objective function into two parts: a smooth quadratic term and a non-smooth characteristic term, which facilitates iterative solution using the alternating direction multiplier method.

[0053] S5. Initialize iterative variables and the state of the long short-term memory network. Initialize primitive variables Auxiliary variables Dual variables And the initial hidden state of the Long Short-Term Memory network. and memory cell state These initial values ​​provide a starting point for subsequent iterations.

[0054] S6. Generating approximate solutions to subproblems using Long Short-Term Memory Networks In each iteration In the middle, the approximate solution of the previous time step will be used. and its gradient Input long short-term memory network units, such as Figure 2 As shown.

[0055] The update direction is calculated using a gating mechanism (input gate, forget gate, output gate), and an approximate solution for the current iteration is output. .

[0056] Specifically, first, define:

[0057] In each iteration, the LSTM unit receives the approximate solution and its gradient from the previous time step as input, and outputs the updated approximate solution:

[0058] This LSTM unit simulates the behavior of a first-order optimization algorithm by utilizing the gradient information of subproblems and accelerates convergence by using the approximate solution from the previous time step as an initial estimate. The parameters of the LSTM unit are shared across all iterations. The specific iterative process is as follows:

[0059] Among them, hidden state With memory cell state Used for encoding time dependencies To hide the number of units. The gating mechanism is responsible for regulating the flow of information: input gate. Control features to memory units Integration, Forgotten Gate Adjustment to historical state The degree of retention, output gate Then through hidden state Control information transmission. Update direction. Depend on The calculated parameters are used to drive the updates of the iterative variables. Trainable parameters include the input weights. Circular weights Output weights and bias terms and .in, , and These represent the Sigmoid activation function, the hyperbolic tangent function, and the Hadamard product, respectively.

[0060] S7. Determine whether the approximate solution satisfies the inaccuracy condition. Determine the approximate solution of the output of the Long Short-Term Memory network Does the condition for sufficient descent meet?

[0061] and gradient conditions:

[0062] If the conditions are met, proceed directly to step S9; if not, trigger the safety guard mechanism and proceed to step S8.

[0063] S8. Implement the safety guard mechanism and switch to traditional gradient descent. When the output of the Long Short-Term Memory network fails to meet the imprecise condition in step S7, a step size of 1 is applied to the subproblem. of Step gradient descent to calculate an approximate solution that satisfies the conditions. :

[0064] This guarantee mechanism ensures that the approximate solution in each iteration strictly satisfies the accuracy condition required for convergence, and is activated only during the inference phase, without affecting the training process.

[0065] S9, Update auxiliary variables Based on the approximate solution of the current iteration Through element-wise projection operation:

[0066] Update auxiliary variables This update has a closed-form architecture and is computationally efficient.

[0067] S10. Update dual variables According to the updated , and penalty parameters Update dual variables This update ensures that the equality constraints between the original variables and the auxiliary variables are satisfied step by step.

[0068] S11, Execution line search updates relaxation parameters For relaxation parameters The execution line search process selects a step size that satisfies the convergence condition:

[0069] This step is achieved through a learnable adaptive parameter tuning mechanism:

[0070] It has the dual function of accelerating convergence and ensuring algorithm stability.

[0071] S12, Adaptive update of penalty parameters Based on learnable scalars Adaptively update the penalty parameters based on the Lipschitz constant of the problem's objective function. :

[0072] This update employs the Sigmoid transform to alleviate the gradient explosion and vanishing problems, and can perform context-aware adjustments based on instantaneous constraint activities, enhancing the algorithm's adaptability to different problem types.

[0073] S13. Output the final original dual solution. Output process The original solution obtained after the second iteration , and dual solutions This serves as the final solution to the original convex quadratic programming problem.

[0074] S14, Training Neural Network Parameters Using the training dataset generated in step 0 The trainable parameters of the Long Short-Term Memory network in step S6 To optimize the object, a truncated time backpropagation method is adopted. After outputting the primal dual solution in step S13, a self-supervised loss function is used:

[0075] The gradient is calculated and the network parameters are updated. This training process is carried out offline, enabling the Long Short-Term Memory network to learn to generate high-quality approximate solutions that satisfy the imprecise conditions in step S6, so that the safety guard mechanism does not need to be frequently triggered during actual solution solving.

[0076] In another embodiment of the present invention, a learning optimization system for solving quadratic programming problems is provided. This system can be used to implement the above-mentioned learning optimization method for solving quadratic programming problems. Specifically, the learning optimization system for solving quadratic programming problems includes a parameter input and problem transformation module, an approximate solution generation module, a condition judgment and guarantee module, and a variable and parameter update module.

[0077] The parameter input and problem transformation module is used to input the parameters of the convex quadratic programming problem to be solved, and to transform the convex quadratic programming problem into a two-block separable form suitable for iterative updates using the alternating direction multiplier method. An approximate solution generation module, connected to the parameter input and problem transformation module, is used to generate approximate solutions to sub-problems for each iteration based on a long short-term memory network. The condition judgment and guarantee module, connected to the approximate solution generation module, is used to judge whether the approximate solution of the subproblem satisfies the sufficient descent condition and the gradient condition, and to perform gradient descent to obtain an approximate solution that satisfies the conditions if the conditions are not met. The variable and parameter update module, connected to the condition judgment and guarantee module, is used to update auxiliary variables, dual variables, relaxation parameters and penalty parameters, and output the original solution and dual solution of the convex quadratic programming problem.

[0078] This invention provides a terminal device comprising a processor and a memory. The memory stores a computer program, which includes program instructions. The processor executes the program instructions stored in the computer storage medium. The processor may be a Central Processing Unit (CPU), or other general-purpose processors, graphics processing units (GPUs), tensor processing units (TPUs), digital signal processors (DSPs), application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, etc. It is the computing and control core of the terminal, suitable for implementing one or more instructions, specifically suitable for loading and executing one or more instructions to achieve a corresponding method flow or corresponding function. The processor described in this embodiment can be used for the operation of a learning optimization method for solving quadratic programming problems, including: Input the parameters of the convex quadratic programming problem to be solved, including the quadratic matrix, linear term coefficients, constraint matrix, lower bound vector, and upper bound vector. Introduce auxiliary variables to transform the convex quadratic programming problem into an optimization problem with equality constraints and boundary constraints, and introduce the indicator function of the boundary constraints to rewrite the transformed optimization problem into a two-block separable form suitable for iterative updates using the alternating direction multiplier method. Initialize the original variables, auxiliary variables, dual variables, and the hidden states and memory unit states of the long short-term memory network. In each iteration, input the approximate solution and its gradient from the previous time step into the long short-term memory network, and use the long short-term memory network to output the approximate solution of the subproblem in the current iteration. Determine the approximate solution of the subproblem. The algorithm checks whether the preset sufficient descent condition and gradient condition are simultaneously satisfied. When the approximate solution to the subproblem does not satisfy the sufficient descent condition and gradient condition, it performs gradient descent for the corresponding subproblem for a preset number of steps to obtain an approximate solution that satisfies the sufficient descent condition and gradient condition. Based on the approximate solution that satisfies the sufficient descent condition and gradient condition, it updates the auxiliary variables through element-wise projection and updates the dual variables according to the updated original variables, auxiliary variables, and penalty parameters. It adaptively learns the relaxation parameters and adaptively updates the penalty parameters according to the learnable scalar and the Lipschitz constant of the objective function. It outputs the original solution and dual solution obtained after a preset number of iterations as the solution result of the convex quadratic programming problem.

[0079] Please see Figure 3 The terminal device is a computer device. In this embodiment, the computer device 60 includes a processor 61, a memory 62, and a computer program 63 stored in the memory 62 and executable on the processor 61. When executed by the processor 61, the computer program 63 implements the learning optimization method for solving quadratic programming problems in this embodiment. To avoid repetition, these details are not elaborated here. Alternatively, when executed by the processor 61, the computer program 63 implements the functions of each model / unit in the learning optimization system for solving quadratic programming problems in this embodiment. To avoid repetition, these details are not elaborated here.

[0080] Computer device 60 can be a desktop computer, laptop, handheld computer, cloud server, or other computing device. Computer device 60 may include, but is not limited to, a processor 61 and a memory 62. Those skilled in the art will understand that... Figure 3 This is merely an example of computer device 60 and does not constitute a limitation on computer device 60. It may include more or fewer components than shown, or combine certain components, or different components. For example, computer device may also include input / output devices, network access devices, buses, etc.

[0081] The processor 61 may be a Central Processing Unit (CPU), or other general-purpose processors, graphics processing units (GPUs), tensor processing units (TPUs), digital signal processors (DSPs), application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, etc. A general-purpose processor may be a microprocessor or any conventional processor.

[0082] The memory 62 can be an internal storage unit of the computer device 60, such as a hard disk or memory of the computer device 60. The memory 62 can also be an external storage device of the computer device 60, such as a plug-in hard disk, smart media card (SMC), secure digital (SD) card, flash card, etc. equipped on the computer device 60.

[0083] Furthermore, the memory 62 may include both internal storage units of the computer device 60 and external storage devices. The memory 62 is used to store computer programs and other programs and data required by the computer device. The memory 62 can also be used to temporarily store data that has been output or will be output.

[0084] Please see Figure 4 The terminal device is an electronic device 600, which is manifested in the form of a general-purpose computing device. The components of the electronic device may include, but are not limited to: at least one processing unit 610, at least one storage unit 620, a bus 630 connecting different platform components (including storage unit 620 and processing unit 610), a display unit 640, etc.

[0085] The storage unit stores program code, which can be executed by the processing unit 610 to perform the steps described in the method section of this specification according to various exemplary embodiments of the present invention. For example, the processing unit 610 can perform actions such as... Figure 1 The steps are shown in the figure.

[0086] Storage unit 620 may include readable media in the form of volatile storage units, such as random access memory (RAM) 6201 and / or cache memory 6202, and may further include read-only memory (ROM) 6203.

[0087] Storage unit 620 may also include a program / utility 6204 having a set (at least one) program module 6205, such program module 6205 including but not limited to: operating system, one or more application programs, other program modules and program data, each or some combination of these examples may include an implementation of a network environment.

[0088] Bus 630 can represent one or more of several types of bus structures, including a memory cell bus or memory cell controller, a peripheral bus, a graphics acceleration port, a processing unit, or a local bus using any of the multiple bus structures.

[0089] Electronic device 600 can also communicate with one or more external devices 700 (e.g., keyboard, pointing device, Bluetooth device, etc.), and with one or more devices that enable a user to interact with electronic device 600, and / or with any device that enables electronic device 600 to communicate with one or more other computing devices (e.g., router, modem). This communication can be performed via input / output interface 650. Furthermore, electronic device 600 can also communicate with one or more networks (e.g., local area network, wide area network, and / or public network, such as the Internet) via network adapter 660. Network adapter 660 can communicate with other modules of electronic device 600 via bus 630. It should be understood that, although not shown in the figures, other hardware and / or software modules can be used in conjunction with electronic device 600, including but not limited to: microcode, device drivers, redundant processing units, external disk drive arrays, RAID systems, tape drives, and data backup storage platforms.

[0090] This invention also provides a storage medium, specifically a computer-readable storage medium, which is a memory device in a terminal device for storing programs and data. It is understood that the computer-readable storage medium here can include both built-in storage media in the terminal device and extended storage media supported by the terminal device; it can be any tangible medium containing or storing a program that can be used by or in conjunction with an instruction execution system, apparatus, or device. The computer-readable storage medium provides storage space that stores the terminal's operating system. Furthermore, the storage space also stores one or more instructions suitable for loading and execution by a processor, which can be one or more computer programs (including program code). More specific examples of the computer-readable storage medium include: an electrical connection with one or more wires, a portable disk, a hard disk, random access memory, read-only memory, erasable programmable read-only memory, optical fiber, portable compact disk read-only memory, optical storage device, magnetic storage device, or any suitable combination thereof.

[0091] Computer-readable storage media also include data signals propagated in baseband or as part of a carrier wave, carrying readable program code. Such propagated data signals can take various forms, including but not limited to electromagnetic signals, optical signals, or any suitable combination thereof. A readable storage medium can also be any readable medium other than a readable storage medium that can send, propagate, or transmit a program for use by or in connection with an instruction execution system, apparatus, or device. The program code contained on the readable storage medium can be transmitted using any suitable medium, including but not limited to wireless, wired, optical fiber, radio frequency, etc., or any suitable combination thereof.

[0092] Program code for performing the operations of this invention can be written in any combination of one or more programming languages, including object-oriented programming languages ​​such as Java and C++, and conventional procedural programming languages ​​such as C or similar languages. The program code can execute entirely on the user's computing device, partially on the user's device, as a standalone software package, partially on the user's computing device and partially on a remote computing device, or entirely on a remote computing device or server. In cases involving remote computing devices, the remote computing device can be connected to the user's computing device via any type of network, including a local area network (LAN) or a wide area network (WAN), or it can be connected to an external computing device (e.g., via the Internet using an Internet service provider).

[0093] One or more instructions stored in a computer-readable storage medium can be loaded and executed by a processor to implement the corresponding steps of the learning optimization method for solving quadratic programming problems in the above embodiments; one or more instructions in the computer-readable storage medium are loaded and executed by the processor to perform the following steps: Input the parameters of the convex quadratic programming problem to be solved, including the quadratic matrix, linear term coefficients, constraint matrix, lower bound vector, and upper bound vector. Introduce auxiliary variables to transform the convex quadratic programming problem into an optimization problem with equality constraints and boundary constraints, and introduce the indicator function of the boundary constraints to rewrite the transformed optimization problem into a two-block separable form suitable for iterative updates using the alternating direction multiplier method. Initialize the original variables, auxiliary variables, dual variables, and the hidden states and memory unit states of the long short-term memory network. In each iteration, input the approximate solution and its gradient from the previous time step into the long short-term memory network, and use the long short-term memory network to output the approximate solution of the subproblem in the current iteration. Determine the approximate solution of the subproblem. The algorithm checks whether the preset sufficient descent condition and gradient condition are simultaneously satisfied. When the approximate solution to the subproblem does not satisfy the sufficient descent condition and gradient condition, it performs gradient descent for the corresponding subproblem for a preset number of steps to obtain an approximate solution that satisfies the sufficient descent condition and gradient condition. Based on the approximate solution that satisfies the sufficient descent condition and gradient condition, it updates the auxiliary variables through element-wise projection and updates the dual variables according to the updated original variables, auxiliary variables, and penalty parameters. It adaptively learns the relaxation parameters and adaptively updates the penalty parameters according to the learnable scalar and the Lipschitz constant of the objective function. It outputs the original solution and dual solution obtained after a preset number of iterations as the solution result of the convex quadratic programming problem.

[0094] The databases involved in the embodiments provided in this application may include at least one type of relational database and non-relational database. Non-relational databases may include, but are not limited to, blockchain-based distributed databases. The processors involved in the embodiments provided in this application may be general-purpose processors, central processing units, graphics processing units, digital signal processors, programmable logic devices, quantum computing-based data processing logic devices, etc., and are not limited to these.

[0095] 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, not all, of the embodiments of the present invention. The components of the embodiments of the present invention described and shown in the accompanying drawings can generally be arranged and designed in various different configurations. Therefore, the following detailed description of the embodiments of the present invention provided in the accompanying drawings is not intended to limit the scope of the claimed invention, but merely to illustrate selected embodiments of the invention. All other embodiments obtained by those skilled in the art based on the embodiments of the present invention without inventive effort are within the scope of protection of the present invention.

[0096] Simulation Experiment To verify the performance of the I-ADMM-LSTM of this invention, traditional ADMM, OSQP, interior point method and pure neural network solver were selected for comparison. Tests were conducted in four typical scenarios: financial portfolio optimization, autonomous driving MPC, large-scale SVM training and power grid optimal power flow. The hardware platform was Intel i7-12700H, NVIDIA RTX3060 and embedded ARM Cortex-A76.

[0097] Real-time performance comparison: In dynamic parameter scenarios, the average solution time of this invention is 0.83s, while that of the traditional OSQP is 6.7s and the interior point method is 12.4s, which is 7-15 times faster and meets the millisecond-level control requirements.

[0098] Accuracy and constraint satisfaction rate: The optimality error of the solution of this invention is <0.1%, the constraint satisfaction rate is 100%, while the error of the pure neural network is >3% and there are constraint violations.

[0099] Edge deployment test: When running a large-scale QP problem on an embedded device, the memory usage of this invention is <128MB, while that of the traditional algorithm is >1GB, and it can be stably deployed on edge devices.

[0100] Robustness test: In scenarios of parameter mutation and distribution shift, the present invention achieves a 100% success rate due to the safety guard mechanism, while traditional algorithms and pure neural networks both fail or fail to converge.

[0101] Experiments show that the present invention is superior to existing methods in terms of speed, accuracy, stability, and resource consumption, and can meet the industrial-grade requirements for real-time, reliable, and lightweight solutions.

[0102] The learning optimization method based on the inaccurate alternating direction multiplier method (I-ADMM-LSTM) proposed in this invention is essentially a general, efficient, and theoretically convergent convex quadratic programming solver. Since quadratic programming problems occupy a core position in many fields such as engineering, finance, artificial intelligence, energy, and robotics, the technical achievements of this invention can be directly transformed into solving the following specific technical problems and integrated into corresponding technical solutions: Portfolio optimization and risk management in the financial sector In quantitative investment and asset management, it is necessary to quickly calculate the optimal holding ratio among thousands of financial assets. Traditional algorithms often miss the best trading opportunities due to excessive computational delays when facing sharp market fluctuations and frequent portfolio adjustments (such as high-frequency trading). In addition, when the number of investment targets and risk constraints (such as industry concentration and leverage limits) change, traditional solvers need to perform expensive matrix decomposition again, making it difficult to achieve real-time response.

[0103] This invention can be embedded in high-frequency trading systems or robo-advisor platforms. Utilizing its ability to batch process all parameter changes (i.e., the training data in step 0 covers different asset portfolios and risk preferences), when market conditions change leading to changes in expected returns or covariance matrices (i.e., in the problem...), it can... and When updating in real time, the trained I-ADMM-LSTM network does not need to restart complex numerical iterations. It can quickly output the new optimal position through forward propagation alone, which solves the technical problem that traditional optimization algorithms cannot take into account both real-time performance and optimality in financial scenarios.

[0104] Model predictive control in control engineering In autonomous driving, drone flight control, or industrial robotic arm trajectory planning, model predictive control requires repeatedly solving a physically constrained optimal control problem within extremely short control cycles (typically milliseconds) based on current sensor feedback (state variables). Traditional solvers (such as OSQP) often suffer from computational time bottlenecks when dealing with dynamically changing constraint boundaries (such as changes in the position of obstacles ahead) or changes in the state matrix, leading to system response lag or instability.

[0105] This invention can directly replace the core QP solving module in the MPC controller. Since the problem structure of MPC is similar in each control cycle but the parameters (mainly state variables and constraint boundaries) change dynamically, this is precisely the scenario where the "learning optimization" of this invention excels. By embedding LSTM units into the ADMM iteration, the algorithm can output high-precision control commands in a very small number of iterations. Furthermore, the safety guard mechanism ensures that even when the neural network prediction deviates, the solution still satisfies the physical constraints of the control system (such as motor torque limits and steering angle limits), thereby ensuring the driving safety of autonomous vehicles.

[0106] Constrained model training in machine learning Training support vector machines, Lasso regression, or machine learning models with fairness and privacy constraints typically requires solving large-scale convex optimization problems. When the data scale reaches millions or even tens of millions, traditional optimization algorithms (such as interior-point methods) are difficult to deploy on edge devices due to their huge memory consumption and cannot handle dynamically increasing data streams.

[0107] This invention can be applied to model fine-tuning or federated learning scenarios in edge intelligent devices. Leveraging the end-to-end output of optimal solutions, the constrained optimization problem can be transformed into a deep learning forward propagation process. For example, when training a personalized recommendation model on a smartphone, this invention can be used to handle a quadratic programming problem with user privacy budget constraints. Since the iterative structure of I-ADMM-LSTM involves only matrix multiplication and activation functions during inference, it is well-suited for parallel acceleration on NPUs or GPUs, thus solving the problem of traditional optimization algorithms being difficult to deploy on resource-constrained devices.

[0108] Optimal power flow and energy dispatch in power systems In smart grids, the optimal power flow problem requires minimizing generation costs while satisfying physical constraints such as generator output limits and line transmission capacity. With the large-scale integration of renewable energy sources (such as photovoltaics and wind power), the predicted values ​​of grid topology and power generation (i.e., problem parameters) fluctuate frequently, making it difficult for traditional optimization algorithms to complete large-scale grid rescheduling within seconds.

[0109] This invention can be applied to the real-time energy management system of a power grid dispatch center. Utilizing the "inaccurate solution" characteristic of this invention, a neural network can quickly provide an approximate optimal solution while meeting accuracy requirements, significantly shortening the dispatch command issuance time. Furthermore, because this invention provides convergence guarantees, the dispatch center can rely on the solution provided by the algorithm, avoiding power grid operation risks caused by algorithm non-convergence.

[0110] In summary, this invention presents a learning optimization method and system for solving quadratic programming problems. It deeply integrates Long Short-Term Memory (LSTM) networks with the inaccurate alternating direction multiplier method. Through controllable inaccurate solving, a guarantee mechanism, adaptive parameter updates, and offline self-supervised training, it achieves high-speed, high-precision, and highly robust solutions to convex quadratic programming problems. The solution speed is improved by an order of magnitude, eliminating the need for manual parameter tuning. Compared to pure neural network methods, it possesses strict theoretical convergence guarantees and constraint satisfaction capabilities, and can be widely applied in scenarios such as finance, autonomous driving, edge intelligence, and power grid scheduling, overcoming the bottlenecks of existing solvers in terms of real-time performance, reliability, and deployability.

[0111] Those skilled in the art will clearly understand that, for the sake of convenience and brevity, the above-described division of functional units and modules is merely an example. In practical applications, the above functions can be assigned to different functional units and modules as needed, that is, the internal structure of the device can be divided into different functional units or modules to complete all or part of the functions described above. The functional units and modules in the embodiments can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit. The integrated unit can be implemented in hardware or as a software functional unit. Furthermore, the specific names of the functional units and modules are only for easy differentiation and are not intended to limit the scope of protection of this application. The specific working process of the units and modules in the above system can be referred to the corresponding process in the foregoing method embodiments, and will not be repeated here.

[0112] In the above embodiments, the descriptions of each embodiment have different focuses. For parts that are not described in detail or recorded in a certain embodiment, please refer to the relevant descriptions of other embodiments.

[0113] Those skilled in the art will recognize that the units and algorithm steps of the various examples described in conjunction with the embodiments disclosed in this invention can be implemented in electronic hardware, or a combination of computer software and electronic hardware. Whether these functions are implemented in hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods to implement the described functions for each specific application, but such implementations should not be considered beyond the scope of this invention.

[0114] In the embodiments provided by this invention, it should be understood that the disclosed devices / terminals and methods can be implemented in other ways. For example, the device / terminal embodiments described above are merely illustrative. For instance, the division of modules or units is only a logical functional division, and in actual implementation, there may be other division methods. For example, multiple units or components may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the coupling or direct coupling or communication connection shown or discussed may be through some interfaces; the indirect coupling or communication connection between devices or units may be electrical, mechanical, or other forms.

[0115] The units described as separate components may or may not be physically separate. 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 units can be selected to achieve the purpose of this embodiment according to actual needs.

[0116] Furthermore, the functional units in the various embodiments of the present invention can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit. The integrated unit can be implemented in hardware or as a software functional unit.

[0117] If the integrated module / unit is implemented as a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, all or part of the processes in the methods of the above embodiments can also be implemented by a computer program instructing related hardware. The computer program can be stored in a computer-readable storage medium, and when executed by a processor, it can implement the steps of the various method embodiments described above. The computer program includes computer program code, which can be in the form of source code, object code, executable files, or certain intermediate forms. The computer-readable medium can include: any entity or device capable of carrying the computer program code, a recording medium, a USB flash drive, a portable hard drive, a magnetic disk, an optical disk, a computer memory, a read-only memory (ROM), a random-access memory (RAM), an electrical carrier signal, a telecommunication signal, and a software distribution medium, etc.

[0118] This application is described with reference to flowchart illustrations and / or block diagrams of methods, apparatus, and computer program products according to embodiments of this application. It will be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, special-purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, generate instructions for implementing the flowchart... Figure 1 One or more processes and / or boxes Figure 1 A device that provides the functions specified in one or more boxes.

[0119] These computer program instructions may also be stored in a computer-readable storage medium that can direct a computer or other programmable data processing device to function in a particular manner, such that the instructions stored in the computer-readable storage medium produce an article of manufacture including instruction means, which are implemented in a process Figure 1 One or more processes and / or boxes Figure 1 The function specified in one or more boxes.

[0120] These computer program instructions may also be loaded onto a computer or other programmable data processing equipment to cause a series of operational steps to be performed on the computer or other programmable equipment to produce a computer-implemented process, thereby providing instructions that execute on the computer or other programmable equipment for implementing the process. Figure 1 One or more processes and / or boxes Figure 1 The steps of the function specified in one or more boxes.

[0121] The above content is only for illustrating the technical concept of the present invention and should not be construed as limiting the scope of protection of the present invention. Any modifications made to the technical solution based on the technical concept proposed in this invention shall fall within the scope of protection of the claims of this invention.

Claims

1. A learning optimization method for solving quadratic programming problems, characterized in that, Includes the following steps: Input the parameters of the convex quadratic programming problem to be solved, which include the quadratic matrix, linear term coefficients, constraint matrix, lower bound vector, and upper bound vector; By introducing auxiliary variables, the convex quadratic programming problem is equivalently transformed into an optimization problem with equality constraints and boundary constraints. Furthermore, by introducing the characteristic function of the boundary constraints, the transformed optimization problem is rewritten into a two-block separable form suitable for iterative updates using the alternating direction multiplier method. Initialize the original variables, auxiliary variables, dual variables, and the hidden states and memory unit states of the long short-term memory network; In each iteration, the approximate solution and its gradient from the previous time step are input into the Long Short-Term Memory (LSTM) network, and the LSM network is used to output the approximate solution of the subproblem in the current iteration. Determine whether the approximate solution to the subproblem simultaneously satisfies the preset sufficient descent condition and gradient condition; When the approximate solution to the subproblem does not satisfy the sufficient descent condition and the gradient condition, a preset number of gradient descent steps are performed on the corresponding subproblem to obtain an approximate solution that satisfies the sufficient descent condition and the gradient condition; Based on the approximate solution that satisfies the sufficient descent condition and the gradient condition, the auxiliary variable is updated by element-wise projection, and the dual variable is updated according to the updated original variable, auxiliary variable and penalty parameter; The relaxation parameters are learned adaptively, and the penalty parameters are updated adaptively based on the learnable scalar and the Lipschitz constant of the objective function. The original solution and dual solution obtained after a preset number of iterations are output as the solution results of the convex quadratic programming problem.

2. The learning optimization method for solving quadratic programming problems according to claim 1, characterized in that, Before solving the convex quadratic programming problem, a set of identically distributed convex quadratic programming problem samples are collected or simulated from the target application scenario. Each sample includes at least a quadratic matrix, linear term coefficients, constraint matrix, lower bound vector, and upper bound vector. The samples are used to form a training dataset for training the parameters of the long short-term memory network.

3. The learning optimization method for solving quadratic programming problems according to claim 1, characterized in that, After the convex quadratic programming problem is equivalently transformed into an optimization problem with equality constraints and boundary constraints, the optimization problem is rewritten into a two-part separable form with the objective function consisting of smooth quadratic terms and non-smooth indicator terms by introducing the characteristic function of the boundary constraints.

4. The learning optimization method for solving quadratic programming problems according to claim 1, characterized in that, In each iteration, the Long Short-Term Memory (LSTM) network unit receives the approximate solution and its gradient from the previous time step as input, calculates the update direction through the input gate, forget gate, and output gate, and outputs the approximate solution of the subproblem for the current iteration. The parameters of the LSM network unit are shared in each iteration.

5. The learning optimization method for solving quadratic programming problems according to claim 1, characterized in that, Determine whether the approximate solution to the subproblem satisfies a preset imprecision condition. The imprecision condition includes at least a sufficient descent condition and a gradient condition. The approximate solution to the subproblem is accepted for subsequent variable updates only if the approximate solution to the subproblem satisfies both the sufficient descent condition and the gradient condition.

6. The learning optimization method for solving quadratic programming problems according to claim 5, characterized in that, When the approximate solution to the subproblem does not satisfy the sufficient descent condition and the gradient condition, gradient descent with a preset step size and a preset number of steps is performed on the corresponding subproblem to obtain an approximate solution that satisfies the sufficient descent condition and the gradient condition.

7. The learning optimization method for solving quadratic programming problems according to claim 1, characterized in that, When updating the auxiliary variable, the updated value of the auxiliary variable is obtained through element-wise projection operation; when updating the dual variable, the dual variable is updated according to the updated original variable, auxiliary variable and penalty parameter.

8. The learning optimization method for solving quadratic programming problems according to claim 1, characterized in that, A line search is performed on the relaxation parameters, and the relaxation parameters are updated through a learnable adaptive parameter adjustment mechanism.

9. The learning optimization method for solving quadratic programming problems according to claim 1, characterized in that, The penalty parameters are adaptively updated based on the learnable scalar and the Lipschitz constant of the objective function of the convex quadratic programming problem, and the penalty parameter update adopts the Sigmoid transformation; furthermore, the trainable parameters of the long short-term memory network are trained offline using the truncated time backpropagation method and the self-supervised loss function.

10. A learning optimization system for solving quadratic programming problems, characterized in that, include: The parameter input and problem transformation module is used to input the parameters of the convex quadratic programming problem to be solved, and to transform the convex quadratic programming problem into a two-block separable form suitable for iterative updates using the alternating direction multiplier method; An approximate solution generation module, connected to the parameter input and problem transformation module, is used to generate approximate solutions to sub-problems for each iteration based on a long short-term memory network. The condition judgment and guarantee module, connected to the approximate solution generation module, is used to judge whether the approximate solution of the subproblem satisfies the sufficient descent condition and the gradient condition, and to perform gradient descent to obtain an approximate solution that satisfies the conditions if the conditions are not met. The variable and parameter update module, connected to the condition judgment and guarantee module, is used to update auxiliary variables, dual variables, relaxation parameters and penalty parameters, and output the original solution and dual solution of the convex quadratic programming problem.

Images