Large-scale unit commitment solving method based on first-order optimization and successive fixation

Abstract

The invention provides a large-scale unit commitment solving method based on first-order optimization and successive fixation, and relates to the field of data processing. In the method, through instance perception preprocessing scaling, normalization is carried out on related parameters of a power system generator set, a linear relaxation model is generated and input into a first-order linear programming solver, and a continuous domain solution vector is obtained through iterative updating. And calculating confidence and logic consistency of binary start-stop, start-stop and shutdown variables based on the solution vector, and outputting a weighted confidence rule set for successive fixation. And if the conditions are met, solidifying the variables, updating the linear relaxation model, and inputting into a solver to obtain a new solution. After multiple rounds of successive fixation are executed, if the number of the fixed binary variables exceeds a threshold value, a small-scale mixed integer linear model is constructed, accurate solving is conducted through a branch shear method, and finally an executable generator set combination plan is output. By implementing the technical scheme provided by the invention, the solving efficiency of the server in processing the SCUC problem can be improved.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of data processing, and particularly relates to a large-scale unit commitment solving method based on first-order optimization and successive fixing. BACKGROUND

[0002] In the dispatching and operation of a power system, a security constrained unit commitment (SCUC) problem is a core optimization problem, and the goal is to reasonably arrange the start-stop state and power output of generating units to ensure that the system operation cost is optimized while meeting power demand.

[0003] At present, the SCUC problem is usually modeled as a mixed integer linear programming (MILP) problem, involving a large number of integer variables and continuous variables. This problem faces a significant computational efficiency bottleneck when solving, especially in large-scale power systems. The MILP model introduces factors such as the start-stop state of generating units, power generation constraints, ramp rate constraints, minimum start-stop time constraints, and grid safety constraints (such as N-1 safety constraints), forming an optimization problem containing a large number of integer and continuous variables. Especially when the scale of the power system expands to thousands of buses or even larger, the traditional solving method often causes the server's computation time to grow exponentially, making it difficult to meet the needs of real-time dispatching and optimization.

[0004] Therefore, how to improve the solving efficiency of the server when processing the SCUC problem, especially in large-scale power systems, has become an important research direction in the field of power system dispatching and optimization. SUMMARY

[0005] The present application provides a large-scale unit commitment solving method based on first-order optimization and successive fixing, which facilitates improving the solving efficiency of the server when processing the SCUC problem.

[0006] In a first aspect of the present application, a large-scale unit commitment solving method based on first-order optimization and successive fixing is provided, the method comprising: obtaining generator unit related parameters for a power system, normalizing the generator unit related parameters through instance perception preprocessing scaling, obtaining a linear constraint set and a target function coefficient matrix, and generating a linear relaxation model according to the linear constraint set and the target function coefficient matrix; inputting the linear relaxation model into a first-order linear programming solver, obtaining a continuous domain relaxation solution vector using an iterative updating method, and evaluating convergence through a robust residual and an original dual feasibility measure, outputting a continuous domain solution vector with non-vertex and original dual residual convergence; based on the continuous domain solution vector, calculating confidence indicators and logical consistency indicators of binary start-stop variables, binary start variables and binary stop variables, and outputting a successive fixing strategy with a weighted confidence rule set; if it is determined that the successive fixing strategy indicates that the binary start-stop variables, the binary start variables and the binary stop variables all satisfy a confidence threshold and are compatible with a minimum start-stop time logic, then the start-stop state, the start state and the stop state corresponding to the binary start-stop variables, the binary start variables and the binary stop variables are fixed to an integer domain to form an updated linear relaxation model; inputting the updated linear relaxation model into the first-order linear programming solver, skipping a general scaling process, obtaining a new continuous domain solution vector and a new weighted confidence rule set for use in the next round of successive fixing; performing multiple rounds of successive fixing, and if it is determined that a target round of successive fixing causes the number of binary variables fixed to be greater than a preset number threshold, then constructing a small-scale mixed integer linear model through a fixed result corresponding to the target round of successive fixing, and combining a traditional branch-and-cut framework to perform final solving, and outputting an executable generator unit commitment plan.

[0007] A second aspect of this application provides a large-scale unit combination solution device based on first-order optimization and successive fixation. The device includes an acquisition module and a processing module. The acquisition module is used to acquire relevant parameters of generator units for a power system, normalize the relevant parameters of generator units through instance-aware preprocessing scaling to obtain a linear constraint set and an objective function coefficient matrix, and generate a linear relaxation model based on the linear constraint set and the objective function coefficient matrix. The processing module is used to input the linear relaxation model into a first-order linear programming solver, obtain continuous domain relaxation solution vectors through iterative update, evaluate convergence through robust residuals and primal-dual feasibility metrics, and output continuous domain solution vectors that are non-vertex and whose primal-dual residuals converge. The processing module is also used to calculate the confidence index and logical consistency index of binary start-up variables, binary startup variables, and binary shutdown variables based on the continuous domain solution vectors, and output a successive fixation strategy with a weighted confidence rule set. The processing module is further configured to, if it is determined that the successive fixing strategy indicates that the binary start-stop variable, the binary start variable, and the binary stop variable all satisfy the confidence threshold and are logically compatible with the minimum start-stop time, then solidify the start-stop state, start state, and stop state corresponding to the binary start-stop variable, the binary start variable, and the binary stop variable into the integer domain to form an updated linear relaxation model; the processing module is further configured to input the updated linear relaxation model into the first-order linear programming solver, skip the general scaling process, and obtain a new round of continuous domain solution vectors and a new weighted confidence rule set for use in the next round of successive fixing; the processing module is further configured to perform multiple rounds of successive fixing, and if it is determined that the number of binary variables solidified in the target round of successive fixing is greater than a preset number threshold, then construct a small-scale mixed integer linear model through the fixing results corresponding to the target round of successive fixing, and perform final solution by combining the traditional branch-pruning framework to output an executable generator set combination plan.

[0008] A third aspect of this application provides an electronic device including a processor, a memory, a user interface, and a network interface. The memory is used to store instructions, and both the user interface and the network interface are used to communicate with other devices. The processor is used to execute the instructions stored in the memory to cause the electronic device to perform the method described above.

[0009] A fourth aspect of this application provides a computer-readable storage medium storing instructions that, when executed, perform the method described above.

[0010] In summary, one or more technical solutions provided in this application have at least the following technical effects or advantages: By normalizing the generator parameters, the numerical conditions are improved, avoiding the computational bottleneck caused by numerical instability in traditional mixed-integer linear programming models. This method enhances numerical stability during the solution process, thereby accelerating computation. By avoiding unnecessary general scaling operations, computational overhead is reduced, further improving the solution speed. This is particularly important for large-scale power systems, as traditional linear programming solvers typically require expensive scaling steps when solving large-scale problems. This scheme gradually reduces the model size by fixing the binary start-up, shutdown, and restart variables, transforming it into a smaller-scale mixed-integer linear programming problem. This not only gradually approximates the optimal solution but also effectively reduces unnecessary computational steps, thereby improving overall solution efficiency. By generating a weighted confidence rule set based on the confidence level and logical consistency of each variable, it ensures that variables most likely to approach integer solutions are fixed first. This strategy ensures that the successive fixing process gradually optimizes the solution quality while accelerating the convergence process.

[0011] When the preset threshold for the number of fixed variables is reached, a small-scale MILP model is constructed and solved precisely using the traditional branch-and-prune framework. This method can quickly obtain integer feasible solutions with a significantly reduced problem size, avoiding the computational complexity faced by traditional branch-and-prune methods when solving large-scale MILPs. By successively fixing and dynamically updating the model, direct solutions to large-scale MILP models are avoided. This method gradually shrinks the problem size, making each step simpler and more efficient. During the successively fixing process, the start-up and shutdown states of the variables are ensured to conform to the minimum start-up and shutdown time logical constraints of the power system, guaranteeing the physical feasibility of the solution and avoiding infeasible scheduling schemes due to constraint violations. By introducing robust residuals and primal dual feasibility measures, the convergence of the solution is continuously evaluated, ensuring that each iteration gradually approaches the optimal solution rather than deviating from the correct solution space. Through multiple rounds of successively fixing, the accuracy of the solution is gradually optimized. Each round further reduces the number of variables and shrinks the problem size, enabling faster acquisition of reasonable solutions in real-time scheduling of large-scale power systems, meeting real-time requirements. In the final small-scale model, the traditional branch-and-prune algorithm is used for accurate solution, which can ensure the optimality of the solution and significantly reduce the solution time. This adapts to the complexity of large-scale power systems, thereby improving the server's solution efficiency when dealing with SCUC problems. Attached Figure Description

[0012] Figure 1 A flowchart illustrating a large-scale unit combination solution method based on first-order optimization and successive fixing provided for embodiments of this application; Figure 2 A schematic diagram of a large-scale unit combination solution device based on first-order optimization and successive fixing provided for embodiments of this application; Figure 3 This is a schematic diagram of the structure of an electronic device provided in an embodiment of this application.

[0013] Explanation of reference numerals in the attached figures: 21. Acquisition module; 22. Processing module; 31. Processor; 32. Communication bus; 33. User interface; 34. Network interface; 35. Memory. Detailed Implementation

[0014] To enable those skilled in the art to better understand the technical solutions in this specification, the technical solutions in the embodiments of this specification will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, and not all embodiments.

[0015] In the description of the embodiments of this application, the words "for example" or "for instance" are used to indicate examples, illustrations, or explanations. Any embodiment or design that is described as "for example" or "for instance" in the embodiments of this application should not be construed as being more preferred or advantageous than other embodiments or design options. Rather, the use of the words "for example" or "for instance" is intended to present the relevant concepts in a specific manner.

[0016] In the description of the embodiments of this application, the term "multiple" means two or more. For example, multiple systems means two or more systems, and multiple screen terminals means two or more screen terminals. Furthermore, the terms "first" and "second" are used for descriptive purposes only and should not be construed as indicating or implying relative importance or implicitly specifying the indicated technical features. Thus, a feature defined with "first" or "second" may explicitly or implicitly include one or more of that feature. The terms "comprising," "including," "having," and variations thereof all mean "including but not limited to," unless otherwise specifically emphasized.

[0017] To address the aforementioned technical problems, this application provides a large-scale unit combination solution method based on first-order optimization and successive fixation, referring to... Figure 1 , Figure 1 This is a flowchart illustrating a large-scale unit combination solution method based on first-order optimization and successive fixing, provided as an embodiment of this application. The method is applied to a server and includes steps S110 to S160, as follows:

[0018] S110. Obtain relevant parameters of generator sets for the power system, normalize the relevant parameters of generator sets through instance-aware preprocessing scaling, obtain the linear constraint set and objective function coefficient matrix, and generate a linear relaxation model based on the linear constraint set and objective function coefficient matrix.

[0019] Specifically, a server refers to a computer system that provides services, possessing high computing power, storage capacity, and network bandwidth, used to process requests, store data, and execute computational tasks. For example, in the process of power system dispatch optimization, a server can be used to run dispatch algorithms, process large-scale data inputs, such as generator status and load demand, and output optimized dispatch results. Generator-related parameters refer to the operating and technical indicators of each generator in the power system, mainly including power limitations, start-up and shutdown characteristics, operating costs, and ramp rate. These parameters determine the generator's operating mode and cost structure. For example, the maximum power output of a generator, such as 500MW; the minimum power output, such as 50MW; the maximum start-up time, such as 30 minutes; and the ramp rate, such as an increase or decrease of 20MW per hour, are all generator-related parameters.

[0020] Instance-aware preprocessing scaling is a data preprocessing technique used to normalize data based on the characteristics of problem instances. The goal of scaling is to adjust the numerical range of different data features, resulting in better numerical conditions and more stable calculations during the solution process. For example, in power system optimization problems, the power parameters of generator sets may have different orders of magnitude; some generator sets may have a maximum power of 500MW, while others may have 50MW. Instance-aware preprocessing scaling normalizes the power parameters of all generator sets to the same range, such as 0 to 1, thus avoiding computational instability caused by excessive numerical differences. Normalization refers to transforming data according to a certain standardization method so that all data are in the same dimension or range, usually between 0 and 1, to eliminate the influence of different dimensions. For example, if one generator set has a maximum output power of 500MW and another has 50MW, normalization can make their normalized values ​​1 and 0.1 respectively. This makes the influence of all parameters more balanced in the calculation.

[0021] A linear constraint set is a collection of multiple linear constraints that limit the range of values ​​for variables in an optimization problem. Linear constraints are expressed as one or more linear equations or inequalities. For example, in power system dispatching problems, linear constraints might include: power balance constraints (e.g., the total power generation of all generators in the system equals the load demand), generator output power constraints (e.g., the output power of each generator cannot exceed its maximum power), and line thermal limit constraints (e.g., the load on a transmission line cannot exceed its rated capacity). The objective function coefficient matrix is ​​a matrix composed of the coefficients of the objective function in a linear programming model. The objective function is usually a linear function representing the objective to be minimized or maximized in the optimization problem, such as cost or power output. Its coefficients correspond to the influence of different variables on the objective function. For example, in power system generator dispatching problems, the objective function is usually to minimize the generation cost. The objective function coefficient matrix might contain the unit generation cost of each generator, for example, a generation cost of 20 yuan / MWh. Each coefficient is multiplied by the corresponding generator's generation to obtain the total cost.

[0022] Linear relaxation models are linear programming problems that relax integer constraints into continuous constraints. By relaxing integer constraints, the problem becomes easier to solve because linear programming problems are generally easier to handle than mixed-integer programming problems. For example, in a power system, the start-up and shutdown states of generators are usually binary variables, either 0 or 1. However, through linear relaxation, these are relaxed into continuous variables, i.e., values ​​between 0 and 1, making the solution process more efficient. In the relaxation model, the start-up and shutdown states of generators are no longer forced integer values, but rather continuous values ​​floating between 0 and 1.

[0023] By using instance-aware preprocessing scaling, the relevant parameters of the generator set are normalized to obtain a set of linear constraints and an objective function coefficient matrix that improve numerical stability. A linear relaxation model is then generated based on these constraints. This effectively reduces computational complexity and improves solution efficiency, especially when dealing with large-scale power system scheduling problems, enabling faster attainment of approximate optimal solutions.

[0024] Furthermore, the acquired generator unit parameters include the generator unit's maximum generating power, minimum generating power, maximum uphill rate, maximum downhill rate, starting capacity, outage capacity, minimum start-up time, minimum outage time, load demand, line thermal limit, and power transfer distribution factor. These parameters are crucial for establishing a power system dispatch model. These technical parameters of each generator unit affect its dispatch decisions and operating costs within the system. Secondly, the production scaling parameter represents the maximum capacity limit of all generator units, i.e., the maximum generating power output among all generator units in the system. This parameter is used to normalize production-related parameters. The cost scaling parameter is defined as the maximum value among the segmented cost coefficients of all generator units, representing the unit cost at different output power levels. These scaling parameters allow the parameters of different generator units to be adjusted to the same order of magnitude, avoiding calculation instability caused by differences in dimensions.

[0025] The normalization process for production-related and cost-related parameters involves the following steps: Normalizing production-related parameters, such as maximum power, minimum power, ramp rate, and starting capacity. For the maximum power of the i-th generator set... By dividing it by the production scaling parameter Normalization is performed as follows:

[0026] in, The maximum power of the i-th generator unit after normalization; normalization of cost-related parameters, such as unit power generation cost and start-up cost; the unit power generation cost of the i-th generator unit. By dividing it by the cost scaling parameter Normalization is performed as follows: in, The normalized unit power generation cost of the i-th generator unit is defined as follows: after normalization, all production-related and cost-related parameters are within a unified dimension range, ensuring that the parameters of different generator units have a consistent influence in subsequent calculations.

[0027] Based on the normalized production and cost parameters, a linear constraint set and an objective function coefficient matrix are constructed. The linear constraint set includes various constraints in the power system, such as power balance constraints, generator power limits, ramp rate constraints, and start-up and shutdown capacity constraints. For the power balance constraint, the total system power demand is assumed to be... Then the constraint conditions are:

[0028] in, Let be the output power of the i-th generator set. This represents the total number of generator sets in the system. Let the load demand of the system be denoted as . The objective function is typically used to minimize the total operating cost, including generation cost, start-up cost, etc. Assume the unit generation cost of the i-th generator unit is . The total cost can then be expressed as:

[0029] in, The total cost of electricity generation, Let i be the unit power generation cost of the i-th generator unit. Let be the power output of the i-th generator set.

[0030] Based on the linear constraint set and the objective function coefficient matrix, a linear programming (LP) model is generated. This model initially expresses the generator scheduling optimization problem, but since the start-stop states of the generators are binary variables, relaxation operations are required. In this stage, the binary start-stop variables are transformed into continuous variables, i.e., real numbers between 0 and 1. For example, the start-stop variable of the i-th generator... The original binary variable is relaxed into a continuous variable between 0 and 1, as follows:

[0031] This relaxation operation simplifies the model and allows it to be solved using efficient linear programming solvers. Through relaxation, the generator's start-up and shutdown states become continuous values, representing the probability of the generator starting. After relaxation, the resulting linearly relaxed model no longer requires the start-up and shutdown variables to be strictly integers, but allows them to take continuous values, typically between [0,1]. This relaxed model is easier to optimize using standard linear programming solvers, providing an approximate and easily computed solution.

[0032] By employing instance-aware preprocessing scaling and normalization steps, various parameters of generator units in the power system are unified to the same dimension, thereby constructing a linear constraint set and an objective function coefficient matrix. Relaxation operations transform integer constraints into continuous constraints, generating a linear relaxation model, which significantly simplifies the solution process and improves computational efficiency. This method provides a foundation for subsequent accurate solutions, ensuring efficient solution and stability of the optimization problem.

[0033] S120. Input the linear relaxation model into the first-order linear programming solver, obtain the continuous domain relaxation solution vector by iterative update, evaluate the convergence by robust residual and primal-dual feasibility measure, and output the continuous domain solution vector that is non-vertex and whose primal-dual residual converges.

[0034] Specifically, a first-order linear programming solver is an optimization tool that uses the first-order derivative information of the objective function to solve problems iteratively. These solvers are primarily suitable for large-scale linear programming problems and do not rely on traditional matrix factorization techniques; instead, they are based on matrix-vector multiplication, typically exhibiting high computational efficiency and being particularly suitable for parallel computing. For example, in power system optimization, a first-order linear programming solver is used to solve the generator scheduling problem. This solver iteratively updates the solution vector, gradually approximating the optimal solution to efficiently obtain the generator start-up and shutdown schedule. The iterative update method refers to the process of gradually adjusting the current solution value to continuously approach the optimal solution during the solution process. In each iteration, the solution vector is updated according to certain criteria to reduce errors or optimize the objective function. For example, in power system scheduling, a first-order solver iteratively updates the generator power output and start-up / shutdown status until these values ​​converge to the optimal solution. In each iteration, the solver updates the current solution based on the previous solution until the solution stabilizes.

[0035] A continuous-domain relaxation solution vector refers to a solution vector obtained after a relaxation operation where variables can take any real value instead of integers, resulting in a solution vector that lies within a continuous domain. Unlike traditional integer solutions, continuous solution vectors contain approximate values ​​for all variables, typically falling between 0 and 1. For example, suppose the start-stop variable for a generator unit takes a value of 0.75 in a linear relaxation model, indicating that the generator unit is in an on-state with a 75% probability during that time period. This solution vector is a continuous value, not a traditional integer solution. Robust residuals are a measure of the difference between the current solution and the ideal solution, especially under conditions of high uncertainty. Robust residuals are commonly used to evaluate the stability and accuracy of optimization solutions, helping to determine the convergence status during the iteration process. Smaller residuals indicate that the solution is close to the optimal solution, while larger residuals indicate that the solution has a significant deviation. For example, in power system dispatching, suppose the continuous solution vector obtained through a linear relaxation model represents the start-stop status of each generator unit. If the robust residual is small, it indicates that the solution vector is stable while approaching the optimal solution. If the residual is large, it means that the optimization process has not yet fully converged and further iterations are needed.

[0036] The primal-dual feasibility metric is used to evaluate whether the primal and dual solutions to a linear programming problem meet feasibility conditions. During optimization, both the primal and dual solutions need to satisfy their respective constraints, and the primal-dual feasibility metric is used to detect the degree of compliance between these two solutions. For example, in the power dispatching problem, the primal solution might be the generating power of each generator unit, while the dual solution corresponds to the associated constraints, such as power balance constraints and Lagrange multipliers for load demand. By evaluating the primal-dual feasibility metric, it can be ensured that the generator unit dispatching plan simultaneously satisfies power balance and other constraints.

[0037] A non-vertex solution refers to a solution in a linear programming problem that is not a basic feasible solution. In linear programming, vertex solutions typically correspond to extreme points in the feasible region, while non-vertex solutions may lie inside or on the boundary of the feasible region, but are not extreme solutions. For example, in the power dispatching problem, if the generating capacity of a generator set is 0.7MW, it means that the start-stop state of the generator set is not completely fixed as integers. This solution is a non-vertex solution in the continuous domain; although it is close to the optimal solution, it is not necessarily located at an extreme point in the feasible solution space. A continuous domain solution vector refers to an optimization problem in which, after relaxation, all variables are allowed to take values ​​within a continuous range, rather than being limited to integer values. For example, in the power dispatching problem, a continuous domain solution vector might represent the start-stop probability of a generator set at different time periods. For instance, if the start-stop state of a generator set at a certain time period is 0.75, it means that the unit has a 75% probability of being started; this state is a continuous domain solution.

[0038] Convergence refers to the property of an optimization algorithm that its solution gradually approaches the optimal solution as iterations proceed. An algorithm is said to be convergent if it can obtain an exact or near-optimal solution within a finite number of steps. For example, in the process of power dispatch optimization, a first-order linear programming solver iteratively updates the solution vector. If, after multiple iterations, the solution vector changes tend to stabilize, and the residual and dual feasibility measure tend to zero, it indicates that the optimization process has converged and the solution is close to the optimal solution.

[0039] Furthermore, the updated linear relaxation model is input into a first-order linear programming solver for iterative updates. Unlike traditional linear programming solvers, the first-order solver performs iterative optimization based on the first derivative of the objective function, i.e., gradient information. In each iteration, the solver updates the solution vector through matrix-vector multiplication. Specifically, its core steps involve the algorithm simultaneously updating the original and dual variables at each step: first, a tentative shift is made along the gradient direction; then, a projection step ensures the feasibility of the solution; and finally, the solution vector converges to the optimal solution based on a dynamically adjusted step size. The convergence state is evaluated by monitoring the original and dual residuals throughout the process.

[0040] In this way, the solver updates the solution in each iteration, gradually approaching the optimal solution. After each iteration, the solver evaluates the convergence of the current solution using robust residuals and primal-dual feasibility metrics. Robust residuals measure the change in the solution vector, while primal-dual feasibility metrics test the feasibility of the primal and dual solutions.

[0041] The solver outputs a non-vertex solution vector when the robust residual and the primal-dual feasibility measure satisfy the convergence condition. In optimization problems, vertex solutions typically correspond to the poles of the feasible region, while non-vertex solutions lie elsewhere in that space. Although a non-vertex solution is not necessarily the optimal solution, it satisfies all constraints and is usually very close to the optimal solution. Non-vertex solutions can be used for subsequent integerization. For example, in power system dispatching, the start-stop state of a generator unit might take a value of 0.75 in a relaxation model, meaning that the unit has a 75% probability of being activated; this solution is a non-vertex solution.

[0042] After convergence, the solver outputs a solution vector that is a continuous domain solution vector, containing the optimal continuous values ​​of all variables. This continuous domain solution vector represents continuous variables such as the generator's start-up and shutdown status and power generation over different time periods. This solution vector provides input for subsequent successive fixing processes, gradually transforming these continuous values ​​into integer solutions to ultimately obtain integer solutions that conform to actual operation. For example, the generator's start-up and shutdown status can be represented by values ​​in the continuous domain solution vector, such as 0.8, which indicates an 80% probability of the unit starting. In subsequent steps, these values ​​are successively fixed and transformed into integers.

[0043] By iteratively updating a first-order linear programming solver and combining robust residuals with primal-dual feasibility metrics to assess convergence, a non-vertex, continuous-domain solution vector that meets the convergence criteria is gradually obtained. This solution vector provides reliable input for subsequent integerization processing and can ultimately be used to optimize generator scheduling in power systems. This method, through iterative updates and convergence evaluation, ensures the stability and accuracy of the optimization process and is suitable for scheduling problems in large-scale power systems.

[0044] S130. Based on the solution vector of the continuous domain, calculate the confidence index and logical consistency index of the binary start-stop variable, the binary start variable and the binary stop variable, and output the successive fixing strategy of the weighted confidence rule set.

[0045] Specifically, a binary start / stop variable refers to a binary decision variable indicating whether a generator set starts or stops. It typically takes the value 0 or 1, where 1 indicates the generator set is in a starting state, and 0 indicates it is in a stopped state. In traditional mixed-integer linear programming problems, the start / stop state is an integer variable. For example, a start / stop variable of 1 for a generator set indicates that the set is started; a start / stop variable of 0 indicates that the set is stopped. In a continuous-domain relaxation model, this variable might be 0.75, indicating a 75% probability that the set is started. A binary start variable is a binary decision variable used to indicate whether a generator set starts, taking the value 0 or 1. Similar to the binary start / stop variable, the start variable specifically describes whether a generator set has started at a certain time period. 1 indicates the generator set is started, and 0 indicates it is not started. For example, in power dispatching, assuming a start variable of 1 for a generator set indicates that the set has started and is participating in power generation; if the start variable is 0, it indicates that the set is not started. A binary shutdown variable is a binary decision variable indicating whether a generator set is shut down. It typically takes the value 0 or 1, where 1 indicates the unit is shut down and 0 indicates it is not shut down. It is used to describe the shutdown status of a generator set. For example, if the shutdown variable for a generator set is 1, it means the unit is shut down; if the shutdown variable is 0, it means the unit is in the startup state or is running.

[0046] Confidence indexes measure the reliability or certainty of a decision variable. In optimization, confidence indicates whether a binary variable is close to its integer value. If the variable value in the continuous domain solution vector is close to 0 or 1, the confidence is high; if the variable value is close to 0.5, the confidence is low. In power system dispatching problems, if the start-stop variable of a generator unit is 0.9, it means that the unit has a 90% probability of being started, and its confidence is high; if its value is 0.3, it means that its start probability is low, and its confidence is low. Confidence reflects the reliability of the optimized solution vector. Logical consistency indexes measure whether binary variables that are temporally adjacent maintain consistency. In generator unit dispatching problems, logical consistency means that the start-stop state of a generator unit should follow the system's start-stop time constraints, such as minimum start-up time and minimum shutdown time. If the start-stop state of a generator unit does not violate these time constraints in adjacent time periods, its logical consistency is high; otherwise, its logical consistency is low. For example: Suppose a generator unit starts in time period t and remains running in time period t+1, then the logical consistency is high; if the unit does not meet the minimum downtime constraint of the system in time period t+1 and suddenly stops, that is, the start-stop variable is 0, then the logical consistency is low.

[0047] A weighted confidence rule set is a set of rules generated based on confidence and logical consistency metrics. In this rule set, each binary variable is assigned a weight value that combines confidence and logical consistency. For example, variables with high confidence and logical consistency will be assigned higher weights, while variables with low confidence and logical inconsistency will be assigned lower weights.

[0048] The successive fixation strategy refers to gradually fixing the most reliable and logically consistent binary variables according to a weighted confidence rule set during the solution process. The goal of successive fixation is to simplify the problem by prioritizing the fixing of variables with high confidence and logical consistency, ultimately leading to a feasible integer solution. For example, in the power dispatching problem, the successive fixation strategy might first fix the start-up and shutdown states of generator units with high confidence and logical consistency, such as start-up and shutdown variables that are very close to 0 or 1, and gradually transform them into integer solutions. Variables with lower confidence are left for further optimization in subsequent steps.

[0049] Furthermore, confidence and logical consistency indices are calculated for binary start-stop, binary initiation, and binary shutdown variables based on the continuous domain solution vectors. These indices are then used to generate a weighted confidence rule set to guide the successive fixing strategy. First, based on the continuous domain solution vectors, confidence and logical consistency indices are calculated for each binary start-stop, binary initiation, and binary shutdown variable. Confidence Indicator: Confidence measures how close a continuous domain variable is to an integer solution. Generally, a higher confidence level is indicated when the variable value is close to 1 or close to 0. The confidence index can be calculated using the maximum gap between the variable value and the set of integers (0 and 1), as shown in the following formula:

[0050] in, Indicates the first Confidence index for two binary variables It is the first The continuous solution values ​​of each variable. When The closer it is to 0 or 1, The larger the value, the closer the decision for that variable is to being completely certain.

[0051] Logical consistency metrics are used to measure whether the relationship between start-up and stop variables in adjacent time periods conforms to system constraints. For example, if a generator set is in time period... If it starts, then it will be in the time period. The system should not be shut down immediately unless the minimum downtime constraint is met. Logical consistency is typically calculated by comparing the compatibility of start and stop variables between adjacent time periods, as shown in the following formula:

[0052] in, Indicates the first Each generator set during the time period and time period The logical consistency of start-stop state changes. and The generator set is located during the following time periods. and time period The values ​​of the start and stop variables. If the difference between the two is small, the logical consistency is high, indicating that the start and stop states meet the system's minimum start and stop time constraints.

[0053] After calculating the confidence and logical consistency indices for each variable, the next step is to generate a weighted confidence rule set based on these indices. The weighted confidence rule set is a collection of rules where each binary variable has a weight associated with its confidence and logical consistency. Variables with higher weights are preferentially fixed to integer values ​​during the successive fixing process, ensuring that the most reliable solution is determined first. Specifically, the weights can be calculated using the following formula:

[0054] in, It is the first The weights of each variable, and These are the weight adjustment coefficients, which control the impact of confidence and logical consistency on the final weights, respectively. It is a confidence index for variables. It is an indicator of the logical consistency of variables. Generally, higher confidence and stronger logical consistency will result in higher weights, thus being determined first in the successive fixation process.

[0055] Based on the generated weighted confidence rule set, a successive fixing strategy is output. This strategy gradually reduces the solution space by prioritizing the fixing of binary variables with higher weights, bringing the solution closer to integer values. Specifically, the successive fixing strategy sorts variables by their weights, starting with the variable with the highest weight and gradually fixing it to integer values. Each fixing reduces the problem size, allowing the remaining variables to be solved within a smaller solution space. For example, suppose the start-stop variable of a generator unit occurs during a specific time period... The confidence level of a variable is 0.9, and it exhibits high logical consistency with the start-up and shutdown states of adjacent time periods. For example, it may satisfy the minimum downtime constraint, thus its weight is likely to be larger. This means that this variable will be fixed first during the successive fixing process. Variables with lower confidence levels or poorer logical consistency, such as those with significant start-up and shutdown state changes or those that do not meet system constraints, will be fixed later until other more reliable variables are determined. This successive fixing strategy ensures that system constraints, such as minimum start-up and shutdown times and generator start-up and shutdown state constraints, are met, while minimizing computational load and improving solution efficiency during optimization.

[0056] By calculating the confidence and logical consistency indices of the binary start-stop, startup, and shutdown variables, a weighted confidence rule set is generated, and a successive fixing strategy is output based on this rule set. During the successive fixing process, variables with high confidence and conforming to logical constraints are fixed first, thereby improving the accuracy and efficiency of the solution. This method effectively reduces the size of the optimization problem and accelerates the computation process, ultimately yielding a generator set combination plan that meets the system constraints.

[0057] S140. If it is determined that the binary start-stop variable, binary start variable, and binary stop variable all satisfy the confidence threshold and are logically compatible with the minimum start-stop time, then the start-stop state, start state, and stop state corresponding to the binary start-stop variable, binary start variable, and binary stop variable are fixed to the integer field to form the updated linear relaxation model.

[0058] Specifically, minimum start-up and shutdown time logic refers to constraints on the start-up and shutdown states of generator sets, requiring that the generator set must maintain operation for a minimum period after startup before shutdown, or maintain shutdown for a minimum period after shutdown before restarting. For example, if the minimum start-up time of a generator set is 60 minutes, then the set must maintain operation for at least 60 minutes after startup before shutdown; similarly, if the minimum shutdown time is 30 minutes, then the set must maintain shutdown for at least 30 minutes after shutdown before restarting. Solidification to the integer domain refers to converting continuous variables, such as the start-up and shutdown probabilities in a continuous domain solution, into integer values. In the optimization process, this step is usually performed under a successive fixing strategy, aiming to ensure that the variables ultimately satisfy integer constraints and meet actual scheduling requirements. For example, suppose the start-up and shutdown variable of a generator set is 0.95 in a linear relaxation model, indicating that the set has a 95% probability of starting. During the successive fixing process, if the confidence level of this variable is high and it conforms to the minimum start-up and shutdown time logic, it will be solidified to the integer value 1, indicating that the set will definitely start during that time period.

[0059] Furthermore, firstly, based on the solution vector of the continuous domain, it is determined whether the confidence levels of the binary start-stop variables, binary start variables, and binary shutdown variables meet the preset confidence thresholds. This determination is achieved by comparing the maximum gap between the value of each variable and the set of integers. If the continuous value of a variable is close to 0 or 1, the confidence level of that variable is high and meets the threshold requirement. Additionally, it is necessary to confirm whether the states of these variables comply with the minimum start-stop time logical constraints. The minimum start-stop time logical constraints stipulate that the generator set cannot be immediately shut down after startup, or cannot be immediately restarted after shutdown. To confirm this, the system checks whether the start-stop variables in adjacent time periods comply with the minimum start-stop time requirements. If the change in start-stop state violates these time constraints within adjacent time periods, then the variable does not meet the logical constraints. For example, suppose the start-stop variable of a generator set is 0.95 in the linear relaxation model, indicating that the unit has a 95% probability of starting in a certain time period. If the confidence level of this variable is greater than the preset threshold, and the start-stop state of the unit does not violate the minimum start-stop time constraints within adjacent time periods, then the variable meets the condition.

[0060] Under the condition that the confidence levels of binary start-up, binary start-up, and binary shutdown variables meet the preset thresholds, and that the states of these variables conform to the minimum start-up and shutdown time logical constraints, the continuous values ​​of these variables are fixed to integer values. That is, if a continuous value of a binary variable is close to 1, it is fixed to 1, indicating that the generator unit is starting during that period; if a continuous value is close to 0, it is fixed to 0, indicating that the unit is shut down during that period. The goal of this fixing process is to transform these variables from continuous domain solution vectors to integer solutions, ensuring that the continuous values ​​of these variables are no longer considered in subsequent optimizations, but are instead included as integer values ​​in the optimization solution. For example: Suppose that the start-up / shutdown variable of a generator unit is 0.9 in the linear relaxation model, its confidence level exceeds the preset threshold, and the start-up / shutdown state of the unit does not violate the minimum shutdown time constraint. In this case, the variable will be fixed to the integer value 1, indicating that the start-up / shutdown state of the generator unit during that period has been determined to be starting.

[0061] After fixing the variables to integer values, the system updates the original linear relaxation model based on these fixed binary variables and the corresponding integer domain constraints. The updated model will include integer constraints, indicating that some variables have been fixed as integers and are no longer allowed to vary within continuous intervals. Simultaneously, these fixed continuous constraints are removed. The updated linear relaxation model is a simplified model with a reduced number of variables, all of which have been converted to integer values. Removing the continuous constraints on fixed variables makes the model more concise and facilitates subsequent accurate solutions. For example, suppose in a scheduling problem with multiple generator sets, the start-stop variables of some generator sets have been fixed to 1 or 0. The updated linear relaxation model will treat these fixed variables as integer constraints, remove the continuous constraints on these variables, and retain only the unfixed variables; for example, the start-stop states of other generator sets remain continuous variables.

[0062] By progressively determining and fixing the values ​​of the binary start-stop, initiation, and shutdown variables, and updating the linear relaxation model based on these fixed results, a simplified model containing integer constraints is ultimately generated. This process, through progressive fixing and updating, reduces computational complexity, making subsequent optimization solutions more efficient, and providing effective input for the final integer solution.

[0063] S150. Input the updated linear relaxation model into the first-order linear programming solver, skip the general scaling process, and obtain a new round of continuous domain solution vectors and a new set of weighted confidence rules for use in the next round of successive fixation.

[0064] Specifically, skipping the general scaling process means that when solving linear programming models, the input scaling operations typically performed to improve numerical stability are not executed. Normally, scaling adjusts all variables and constraints to the same dimensionality to reduce numerical errors. However, in this approach, since instance-aware preprocessing and normalization have already been performed, scaling is unnecessary, saving computational resources and time. For example, suppose in a power system dispatching problem, the power output range of all generators has been standardized to [0,1] through instance-aware preprocessing and normalization. In this case, further scaling of these variables is unnecessary during the solution process, thus avoiding additional computational overhead.

[0065] Furthermore, the updated linear relaxation model is first input into a first-order linear programming solver for iterative updates. The updated model has undergone successive fixation strategy processing, with some variables being fixed as integer constraints, while the remaining variables remain continuous. During the iteration process, the solver calculates based on the current solution vector and the constraint matrix, gradually approaching the optimal solution. After each iteration, the solver outputs a new continuous domain solution vector, representing the continuous values ​​of each variable, typically between 0 and 1. These solution vectors reflect information such as the generator unit's start-up and shutdown status and power generation in each time period. Through these new continuous domain solution vectors, the confidence index and logical consistency index of each binary start-up, binary startup, and binary shutdown variable can be further evaluated. The confidence index measures how close the continuous values ​​of these binary variables are to integers. Variables with high confidence indicate that their values ​​are close to 0 or 1, possessing high certainty. The logical consistency index is used to determine whether the start-up and shutdown variables in adjacent time periods meet the system's start-up and shutdown constraints. For example, the start-up and shutdown status of a generator set during a certain period should comply with the constraints of minimum start-up time or minimum shutdown time to ensure that changes in its start-up and shutdown status are reasonable.

[0066] Based on the calculated confidence and logical consistency indices, a weighted confidence rule set is generated. This rule set ranks the weights of each variable, with variables having higher weights typically exhibiting higher confidence and stronger logical consistency. In subsequent rounds of successive fixing, these higher-weighted variables are fixed first, ensuring that the most reliable variables are determined to have integer values ​​first. This approach helps to progressively reduce the solution space of the optimization problem and accelerates the solution process.

[0067] S160. Perform multiple rounds of successive fixing. If the number of binary variables fixed by successive fixing in the target round is greater than the preset threshold, then construct a small-scale mixed integer linear model based on the fixing results corresponding to the successive fixing in the target round, and combine it with the traditional branch-pruning framework to solve the final problem and output an executable generator set combination plan.

[0068] Specifically, a small-scale mixed-integer linear model refers to a simplified linear model obtained by fixing some binary variables and combining them with corresponding integer constraints after multiple rounds of successive fixation. Compared to the original linear relaxation model, this model is smaller in scale, contains more integer constraints, and has fewer remaining continuous variables, thus making it easier to solve. For example, suppose in power system dispatching, through a successive fixation strategy, the start-stop states of some generator units have been determined as integers. Using these fixed results, a model containing only a small number of continuous variables can be constructed, which is easier to solve than the original mixed-integer linear programming model.

[0069] The traditional branch-and-prune framework is a method applied to solving integer linear programming and mixed-integer linear programming problems. This algorithm effectively finds the optimal solution by branching (decomposing a large problem into multiple subproblems) and pruning (eliminating impossible solutions during the search process to reduce the solution space). Branch-and-prune is commonly used to solve optimization problems involving integer variables, especially when the problem size is large, as it can effectively reduce computational load. For example, in the generator scheduling problem of a power system, branch-and-prune is used to break down a large-scale mixed-integer programming problem into several subproblems, and by progressively eliminating impossible solutions, such as overload generation schemes, the solution process is accelerated, ultimately obtaining the optimal scheduling scheme that meets all constraints.

[0070] Final solution refers to obtaining the optimal solution using an exact solution method after multiple rounds of successive fixation and other preprocessing steps during the optimization process. This process typically occurs when the problem size has been significantly reduced and most variables have been fixed as integers. For example, in the power dispatching problem, after multiple rounds of successive fixation, the start-up and shutdown status and power output of generator units are basically determined. At this point, the branch-pruning method is used to precisely solve for the remaining few continuous variables, thereby deriving the final generator unit combination plan. An executable generator unit combination plan refers to a specific dispatching scheme generated during the optimization process that can be practically applied to the operation of the power system. This plan specifies the start-up and shutdown status, power output, and other constraints of each generator unit in each time period, ensuring that the load demand of the power system is met while optimizing power generation costs and system security. For example, in power dispatching, an executable generator unit combination plan might include starting some generator units in specific time periods, keeping other generator units offline, and adjusting the power output of each generator unit according to the system load demand. This plan will ensure that the system meets demand while minimizing power generation costs.

[0071] Furthermore, firstly, a multi-round successive fixing strategy is used to gradually solidify the binary variables in the model. During each round of successive fixing, the values ​​of the binary start-stop, start, and stop variables gradually approach integers, and confidence levels and logical consistency are used to determine which variables are fixed first. After each round, the number of fixed binary variables is checked, and it is determined whether this number exceeds a preset threshold. If it exceeds the preset threshold, the next step of building a small-scale mixed-integer linear model is initiated. In power system dispatching problems, successive fixing may gradually determine the start-stop status of certain generator units. For example, if the start-stop variable of a generator unit is close to 1 during a certain period, it indicates a high probability of start-up, and it can be fixed to 1, continuing to the next step. After each variable fixing, the number of fixed binary variables in the current round is recorded and compared with a preset threshold.

[0072] When the successive fixing operations in the target round result in the number of fixed binary variables exceeding a preset threshold, a small-scale mixed-integer linear model is constructed based on the results of that round of fixing. At this point, the fixed binary variables, such as start-up, shutdown, and restart variables already determined to be 0 or 1, are added to the model as integer constraints. The small-scale model retains only a small number of continuous variables, and the number of integer variables increases, significantly reducing the problem size. For example, in a power system, after multiple rounds of successive fixing, the start-up and shutdown states of some generator units have been determined as integers; for instance, some units have been determined to be started. After successive fixing, the fixed variables are determined as integer values ​​and directly written into the model as constants. For integer variables that have not yet undergone successive fixing, their integer attributes and related constraints are still fully preserved in the model. Since a large number of integer variables have been converted to constants through successive fixing, the feasible solution space of the model is significantly reduced. Subsequent solutions only need to search on the remaining unfixed integer and continuous variables, thus significantly improving the overall solution efficiency.

[0073] Next, the constructed small-scale mixed-integer linear model is input into the traditional branch-and-prune framework for exact solution. Branch-and-prune is an optimization method that reduces the solution space through recursive branching and pruning strategies. During branching, the problem is broken down into multiple subproblems, and integer solutions are found for each subproblem. During pruning, subproblems in the branch tree that do not meet the constraints are eliminated, thus accelerating the solution process. For example, in the power system dispatching problem, the traditional branch-and-prune framework uses branching strategies to decompose the problem into multiple subproblems, such as splitting the start-stop state combinations of different generator units. Each subproblem corresponds to a smaller solution space, and pruning strategies eliminate solutions that do not meet load balancing or generator capacity constraints, thereby improving solution efficiency.

[0074] Once an integer feasible solution satisfying all system constraints is obtained using the branch-and-prune method, an executable generator combination plan is generated based on this solution. This plan specifies the start / stop status and power output of each generator unit at different time periods, ensuring that the power system's load demand is met and optimizing generation costs. The final generator combination plan can be used for actual power system dispatch and unit operation. After obtaining the integer feasible solution, the system will formulate a specific dispatch plan based on it. For example, some generator units may start during specific time periods while others remain offline; the dispatch plan will ensure that power demand is met while minimizing generation costs or other optimization objectives. The generated plan will be used in the actual power dispatch system to guide the operation of the generator units.

[0075] This application also provides a large-scale unit combination solution device based on first-order optimization and successive fixation, referring to... Figure 2 , Figure 2This document provides a schematic diagram of a large-scale generator unit combination solution device based on first-order optimization and successive fixing, as provided in an embodiment of this application. The device is a server, comprising an acquisition module 21 and a processing module 22. The acquisition module 21 acquires relevant parameters of the generator units in the power system, normalizes these parameters through instance-aware preprocessing scaling to obtain a linear constraint set and an objective function coefficient matrix, and generates a linear relaxation model based on these parameters. The processing module 22 inputs the linear relaxation model into a first-order linear programming solver, acquires continuous-domain relaxation solution vectors using an iterative update method, evaluates convergence through robust residuals and primal-dual feasibility metrics, and outputs continuous-domain solution vectors that are non-vertex and whose primal-dual residuals converge. The processing module 22 also calculates confidence and logical consistency indices for binary start-up, binary start-up, and binary shutdown variables based on the continuous-domain solution vectors, and outputs a successive fixing strategy with a weighted confidence rule set. The processing module 22 further... If the successive fixing strategy indicates that the binary start-stop, binary start, and binary stop variables all meet the confidence threshold and are logically compatible with the minimum start-stop time, then the corresponding start-stop, start, and stop states of the binary start-stop, binary start, and binary stop variables are fixed to the integer domain to form an updated linear relaxation model. The processing module 22 is also used to input the updated linear relaxation model into a first-order linear programming solver, skip the general scaling process, and obtain a new round of continuous domain solution vectors and a new set of weighted confidence rules for use in the next round of successive fixing. The processing module 22 is also used to perform multiple rounds of successive fixing. If it is determined that the number of binary variables fixed in the target round of successive fixing is greater than a preset number threshold, then a small-scale mixed integer linear model is constructed through the fixing results corresponding to the target round of successive fixing, and the final solution is performed in combination with the traditional branch-pruning framework to output an executable generator set combination plan.

[0076] It should be noted that the above embodiments of the apparatus are only illustrated by the division of the above functional modules. In practical applications, the above functions can be assigned to different functional modules as needed, that is, the internal structure of the device can be divided into different functional modules to complete all or part of the functions described above. In addition, the apparatus and method embodiments provided in the above embodiments belong to the same concept, and the specific implementation process can be found in the method embodiments, which will not be repeated here.

[0077] This application also provides an electronic device, with reference to... Figure 3 , Figure 3 This is a schematic diagram of the structure of an electronic device provided in an embodiment of this application. The electronic device may include: at least one processor 31, at least one network interface 34, a user interface 33, a memory 35, and at least one communication bus 32.

[0078] The communication bus 32 is used to enable communication between these components.

[0079] The user interface 33 may include a display screen and a camera. Optionally, the user interface 33 may also include a standard wired interface and a wireless interface.

[0080] The network interface 34 may optionally include a standard wired interface or a wireless interface (such as a Wi-Fi interface).

[0081] The processor 31 may include one or more processing cores. The processor 31 connects to various parts of the server via various interfaces and lines, executing instructions, programs, code sets, or instruction sets stored in the memory 35, and calling data stored in the memory 35 to perform various server functions and process data. Optionally, the processor 31 may be implemented using at least one hardware form of Digital Signal Processing (DSP), Field-Programmable Gate Array (FPGA), or Programmable Logic Array (PLA). The processor 31 may integrate one or a combination of several of the following: Central Processing Unit (CPU), Graphics Processing Unit (GPU), and modem. The CPU primarily handles the operating system, user interface, and applications; the GPU is responsible for rendering and drawing the content to be displayed on the screen; and the modem handles wireless communication. It is understood that the modem may also not be integrated into the processor 31 and may be implemented as a separate chip.

[0082] The memory 35 may include random access memory (RAM) or read-only memory. Optionally, the memory 35 may include a non-transitory computer-readable storage medium. The memory 35 can be used to store instructions, programs, code, code sets, or instruction sets. The memory 35 may include a program storage area and a data storage area, wherein the program storage area may store instructions for implementing an operating system, instructions for at least one function (such as touch function, sound playback function, image playback function, etc.), instructions for implementing the above-described method embodiments, etc.; the data storage area may store data involved in the above-described method embodiments, etc. Optionally, the memory 35 may also be at least one storage device located remotely from the aforementioned processor 31. Figure 3 As shown, the memory 35, which serves as a computer storage medium, may include an operating system, a network communication module, a user interface module, and an application program based on a large-scale unit combination solution method using first-order optimization and successive fixation.

[0083] exist Figure 3 In the electronic device shown, the user interface 33 is mainly used to provide an input interface for the user and obtain the user input data; while the processor 31 can be used to call an application program stored in the memory 35 that is based on a large-scale unit combination solution method of first-order optimization and successive fixation. When executed by one or more processors, the electronic device executes one or more methods as described in the above embodiments.

[0084] It should be noted that, for the sake of simplicity, the foregoing method embodiments are all described as a series of actions. However, those skilled in the art should understand that this application is not limited to the described order of actions, as some steps may be performed in other orders or simultaneously according to this application. Furthermore, those skilled in the art should also understand that the embodiments described in the specification are preferred embodiments, and the actions and modules involved are not necessarily essential to this application.

[0085] This application also provides a computer-readable storage medium storing instructions. When executed by one or more processors, these instructions cause an electronic device to perform one or more of the methods described in the above embodiments.

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

[0087] In the several embodiments provided in this application, it should be understood that the disclosed apparatus can be implemented in other ways. For example, the apparatus embodiments described above are merely illustrative; for instance, the division of 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 shown or discussed mutual couplings or direct couplings or communication connections may be through some service interfaces; indirect couplings or communication connections between apparatuses or units may be electrical or other forms.

[0088] 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.

[0089] Furthermore, the functional units in the various embodiments of this application 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.

[0090] If the integrated 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 device (CMD). Based on this understanding, the technical solution of this application, in essence, or the part that contributes to the prior art, or all or part of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a memory 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 this application. The aforementioned memory includes various media capable of storing program code, such as USB flash drives, portable hard drives, magnetic disks, or optical disks.

[0091] The foregoing description is merely an exemplary embodiment of this disclosure and should not be construed as limiting the scope of this disclosure. Any equivalent changes and modifications made in accordance with the teachings of this disclosure shall still fall within the scope of this disclosure. Those skilled in the art will readily conceive of other embodiments of this disclosure upon considering the specification and the disclosure of practical truth. This application is intended to cover any variations, uses, or adaptations of this disclosure that follow the general principles of this disclosure and include common knowledge or customary techniques in the art not described in this disclosure. The specification and embodiments are considered exemplary only, and the scope and spirit of this disclosure are defined by the claims.

Claims

1. A method for solving large-scale unit combination problems based on first-order optimization and successive fixation, characterized in that, The method includes: Obtain relevant parameters of generator sets for the power system, normalize the relevant parameters of generator sets through instance-aware preprocessing scaling, obtain a linear constraint set and an objective function coefficient matrix, and generate a linear relaxation model based on the linear constraint set and the objective function coefficient matrix. The linear relaxation model is input into a first-order linear programming solver, and the continuous domain relaxation solution vector is obtained by iterative update. The convergence is evaluated by robust residual and primal-dual feasibility measure, and the continuous domain solution vector with non-vertex and primal-dual residual convergence is output. Based on the continuous domain solution vector, calculate the confidence index and logical consistency index of the binary start-stop variable, the binary start variable, and the binary stop variable, and output the successive fixing strategy of the weighted confidence rule set. If it is determined that the successive fixing strategy indicates that the binary start-stop variable, the binary start variable, and the binary stop variable all satisfy the confidence threshold and are logically compatible with the minimum start-stop time, then the start-stop state, start state, and stop state corresponding to the binary start-stop variable, the binary start variable, and the binary stop variable are fixed to the integer field to form the updated linear relaxation model. The updated linear relaxation model is input into the first-order linear programming solver, skipping the general scaling process, to obtain a new round of continuous domain solution vectors and a new set of weighted confidence rules for use in the next round of successive fixation. If the successive fixation of the target round results in a number of binary variables being fixed that is greater than a preset threshold, a small-scale mixed integer linear model is constructed based on the fixation results corresponding to the successive fixation of the target round. The model is then combined with a traditional branch-pruning framework to solve the final problem and output an executable generator set combination plan.

2. The method for solving large-scale unit combination based on first-order optimization and successive fixation as described in claim 1, characterized in that, The process of acquiring relevant parameters of generator sets for the power system, normalizing these parameters through instance-aware preprocessing scaling to obtain a linear constraint set and an objective function coefficient matrix, and generating a linear relaxation model based on the linear constraint set and the objective function coefficient matrix specifically includes: The maximum generating power, minimum generating power, maximum uphill ramp rate, maximum downhill ramp rate, starting capacity, shutdown capacity, minimum start-up time, minimum shutdown time, load demand, line thermal limit, and power transfer distribution factor of each generator unit in the power system are obtained to obtain production-related parameters and cost-related parameters. Define production scaling parameters and cost scaling parameters, wherein the production scaling parameter is the maximum capacity limit of the generator set, and the cost scaling parameter is the maximum value among the segmented cost coefficients of the generator set; The production-related parameters are divided by the production scaling parameter, and the cost-related parameters are divided by the cost scaling parameter to generate normalized production parameters and cost parameters. Based on the normalized production and cost parameters, construct the linear constraint set and the objective function coefficient matrix; Based on the set of linear constraints and the coefficient matrix of the objective function, a linear programming model is generated, and the integer constraints in the linear programming model are transformed into continuous constraints through a relaxation operation to obtain the linear relaxation model.

3. The method for solving large-scale unit combination based on first-order optimization and successive fixation as described in claim 1, characterized in that, The process of inputting the linear relaxation model into a first-order linear programming solver, obtaining the continuous domain relaxation solution vector through iterative updates, evaluating convergence through robust residuals and primal-dual feasibility metrics, and outputting a non-vertex continuous domain solution vector with convergent primal-dual residuals specifically includes: The linear relaxation model is input into the first-order linear programming solver, and the continuous domain relaxation solution vector is obtained through the iterative update method, which uses matrix-vector multiplication. Convergence is evaluated using robust residuals and primal-dual feasibility measures. When the robust residuals and primal-dual feasibility measures satisfy the convergence condition, a non-vertex solution vector is output, which is a continuous domain solution vector that meets the convergence criterion.

4. The method for solving large-scale unit combination based on first-order optimization and successive fixing as described in claim 1, characterized in that, Based on the continuous domain solution vector, the confidence index and logical consistency index of the binary start-stop variable, the binary start variable, and the binary stop variable are calculated, and the successive fixing strategy of the weighted confidence rule set is output, specifically including: Based on the continuous domain solution vector, the confidence index and logical consistency index of the binary start-stop variable, the binary start variable, and the binary stop variable are calculated. The confidence index is reflected by the largest gap between the variable values ​​and the set of integers, and the logical consistency index is determined by the compatibility between start-stop variables in adjacent time periods. The weighted confidence rule set is generated based on the confidence index and the logical consistency index. The successive fixing strategy is output based on the weighted confidence rule set to guide the binary variable to be fixed first in the successive fixing process, ensuring that the binary variable logically meets the system constraints.

5. The method for solving large-scale unit combination based on first-order optimization and successive fixation according to claim 1, characterized in that, If it is determined that the successive fixing strategy indicates that the binary start-stop variable, the binary start variable, and the binary stop variable all satisfy the confidence threshold and are logically compatible with the minimum start-stop time, then the start-stop state, start state, and stop state corresponding to the binary start-stop variable, the binary start variable, and the binary stop variable are fixed to the integer field to form an updated linear relaxation model, specifically including: Based on the continuous domain solution vector, determine whether the confidence levels of the binary start-stop variable, the binary start variable, and the binary stop variable meet the preset confidence threshold, and confirm whether the states of the binary start-stop variable, the binary start variable, and the binary stop variable conform to the minimum start-stop time logic constraint. Under the condition that the binary start-stop variable, the binary start variable, and the binary stop variable all meet the confidence threshold and comply with the minimum start-stop time logic constraint, the values ​​of the binary start-stop variable, the binary start variable, and the binary stop variable are fixed as integer values ​​to form an integer field constraint. Based on the fixed variables and the integer domain constraints, the linear relaxation model is updated by incorporating the fixed binary variables into the integer constraints, removing the continuous constraints, and generating the updated linear relaxation model.

6. The method for solving large-scale unit combination based on first-order optimization and successive fixing as described in claim 1, characterized in that, The process of inputting the updated linear relaxation model into the first-order linear programming solver, skipping the general scaling process, and obtaining a new round of continuous domain solution vectors and a new set of weighted confidence rules for subsequent fixed use includes: The updated linear relaxation model is input into the first-order linear programming solver for iterative updates. The linear programming solver updates the continuous domain solution vector based on matrix-vector multiplication and skips the general scaling process in each iteration to improve computational efficiency and reduce solution time. After each iteration, a new round of continuous domain solution vectors is calculated. Based on the new round of continuous domain solution vectors, the confidence index and logical consistency index of the new round of binary start-stop variables, binary start variables and binary stop variables are calculated, and a new weighted confidence rule set is generated according to the calculation results. The new weighted confidence rule set is used as input for the next round of successive fixation to further reduce the model size and optimize the solution process.

7. The method for solving large-scale unit combination based on first-order optimization and successive fixation according to claim 1, characterized in that, The process involves multiple rounds of successive fixing. If the successive fixing of the target round results in a number of binary variables being fixed exceeding a preset threshold, a small-scale mixed-integer linear model is constructed using the fixing results corresponding to the successive fixing of the target round. This model is then combined with a traditional branch-and-prune framework for final solution, outputting an executable generator set combination plan. Specifically, this includes: Perform multiple rounds of successive fixing and determine whether the number of binary variables fixed in each round of successive fixing exceeds a preset threshold. If it is determined that fixing the target rounds one by one results in the number of binary variables being fixed being greater than a preset threshold, then the small-scale mixed integer linear model is constructed based on the fixing result of the target rounds one by one. The small-scale mixed integer linear model includes the fixed binary variables and corresponding integer constraints. The small-scale mixed integer linear model is input into the traditional branch-and-prune framework, and the exact solution is obtained through branching and pruning strategies to output an integer feasible solution that satisfies the system constraints. Based on the integer feasible solutions, an executable generator set combination plan is generated and used for the actual scheduling and operation of the power system.

8. A large-scale unit combination solution device based on first-order optimization and successive fixation, characterized in that, The apparatus is used to execute the large-scale unit combination solution method based on first-order optimization and successive fixing as described in any one of claims 1 to 7, the apparatus comprising an acquisition module and a processing module, wherein... The acquisition module is used to acquire relevant parameters of generator sets for the power system, normalize the relevant parameters of generator sets through instance-aware preprocessing scaling to obtain a linear constraint set and an objective function coefficient matrix, and generate a linear relaxation model based on the linear constraint set and the objective function coefficient matrix. The processing module is used to input the linear relaxation model into a first-order linear programming solver, obtain the continuous domain relaxation solution vector by iterative update, evaluate the convergence by robust residual and primal-dual feasibility measure, and output the continuous domain solution vector that is non-vertex and whose primal-dual residual converges. The processing module is also used to calculate the confidence index and logical consistency index of the binary start-stop variable, the binary start variable and the binary stop variable based on the continuous domain solution vector, and output the successive fixing strategy of the weighted confidence rule set. The processing module is further configured to, if it is determined that the successive fixing strategy indicates that the binary start-stop variable, the binary start variable, and the binary stop variable all satisfy the confidence threshold and are logically compatible with the minimum start-stop time, then fix the start-stop state, start state, and stop state corresponding to the binary start-stop variable, the binary start variable, and the binary stop variable to the integer field to form an updated linear relaxation model. The processing module is also used to input the updated linear relaxation model into the first-order linear programming solver, skip the general scaling process, and obtain a new round of continuous domain solution vectors and a new set of weighted confidence rules for use in the next round of successive fixation. The processing module is also used to perform multiple rounds of successive fixing. If it is determined that the number of binary variables fixed by the successive fixing of the target round is greater than a preset threshold, a small-scale mixed integer linear model is constructed based on the fixing results corresponding to the successive fixing of the target round, and the final solution is obtained by combining the traditional branch pruning framework, and an executable generator set combination plan is output.

9. An electronic device, characterized in that, The electronic device includes a processor, a memory, a user interface, and a network interface. The memory is used to store instructions. The user interface and the network interface are both used to communicate with other devices. The processor is used to execute the instructions stored in the memory to cause the electronic device to perform the method as described in any one of claims 1 to 7.

10. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores instructions that, when executed, perform the method as described in any one of claims 1 to 7.

Images