A method and system for streaming real-time solving of nonlinear equations based on sensitivity caching and vectorized bucketing

Abstract

The application discloses a kind of based on sensitivity cache and vectorization bucketing nonlinear equation set streaming real-time solving method and system, it is related to numerical solving technical field, the method includes: calling the historical input vector of each target object last period, change vector of current input vector relative to historical input vector is obtained by vector difference operation;Each target object is divided to corresponding solving channel based on preset sparse micro-variable threshold and adaptive threshold;The solution result and the solution residual of each target object of current batch are summarized, the average posteriori error of all target objects under the statistical increment path is based on solution result and solution residual, the adaptive threshold is automatically adjusted based on average posteriori error, historical state quadruple is updated according to the difference of the solution channel of target object, and cross-period adaptive feedback link is built, it is helpful to solve the problem that existing technology cannot realize nonlinear equation set streaming real-time solving based on sensitivity cache and vectorization bucketing.

Description

Technical Field

[0001] This invention relates to the field of numerical solution technology, and in particular to a streaming real-time solution method and system for nonlinear equation systems based on sensitivity buffering and vectorized bucketing. Background Technology

[0002] In real-time processing scenarios of large-scale streaming data, there is a common type of computational task: based on the currently observed results data (such as sensor readings, monitoring indicators, market data, etc.), combined with the pre-established model structure and some known model parameters, to reverse-engineer one or more unknown parameters that enable the model output to match the observation results.

[0003] Existing technologies typically perform independent full iterations on each round of streaming data, relying on the previous cycle's convergence and de-heating to accelerate convergence, and using distributed clusters to handle the solution tasks for tens of thousands of target objects in batches. As data push intervals are compressed to the millisecond level, existing solutions expose three major bottlenecks: First, full iterations involve high-overhead operations such as Jacobian matrix construction and matrix inversion, and the solution latency cannot match high-frequency real-time conditions; second, streaming data is mostly updated with minor dimensional changes, and existing solutions do not cache and reuse intermediate states such as sensitivity matrices across cycles, resulting in large amounts of redundant computation and low resource utilization; third, they only rely on distributed horizontal scaling and do not optimize single-machine vectorization, hash bucketing, and memory layout for the solution characteristics, limiting the release of single-machine computing power, and node communication overhead further exacerbates latency.

[0004] In summary, existing technologies struggle to simultaneously meet the requirements of high accuracy, low latency, and high computing power utilization. Therefore, there is an urgent need for a real-time inverse solution method for streaming nonlinear equations that can significantly reduce single-run computation latency, significantly reduce redundant computations, and fully utilize the computing power of a single machine while ensuring solution accuracy. Summary of the Invention

[0005] In view of this, the present invention proposes a streaming real-time solution method and system for nonlinear equations based on sensitivity caching and vectorized bucketing, which can significantly reduce the single-time calculation latency, significantly reduce redundant calculations, and fully utilize the computing power of a single machine while ensuring the accuracy of the solution.

[0006] To achieve the above objectives, the present invention provides the following technical solution: A streaming real-time solution method for nonlinear equation systems based on sensitivity buffering and vectorized bucketing includes: Collect the original input data of each target object in the current batch, normalize the original input data to obtain the current input vector of each target object, retrieve the historical input vector of each target object in the previous period, and obtain the change vector of the current input vector relative to the historical input vector through vector difference operation; Based on a preset sparse infinitesimal threshold and an adaptive threshold, each target object is assigned to a corresponding solution channel. The solution channel includes a sparse sensitivity verification path, an incremental extrapolation verification path, and a full solution path, and outputs the corresponding implicit parameter estimates or iterative initial guesses. For target objects that fail the verification of the full solution path and the incremental extrapolation verification path, a finite number of Newton correction iterations are performed starting from the pre-constructed approximate function table or the initial guess value of the iteration. After the iteration converges, the sensitivity matrix is ​​pre-calculated and the caching is completed. Summarize the solution results and solution residuals for each target object in the current batch, calculate the average posterior error of all target objects under the incremental path based on the solution results and solution residuals, automatically adjust the adaptive threshold based on the average posterior error, update the historical state quadruples according to the solution channel to which the target object belongs, and build a cross-cycle adaptive feedback link. For each target object in the current batch, parameter similarity-aware hash bucketing, state quadruple-guided memory layout transformation, and path-aware vectorized dual-stream parallel scheduling are performed to efficiently map the full solution task to the hardware execution unit.

[0007] Based on the above technical solution, the present invention can be further improved as follows: Optionally, obtaining the change vector of the current input vector relative to the historical input vector through vector interpolation includes: The change vector is calculated using formula (1); Formula (1); In the formula, For the changing vector, This is the current input vector. Let t be the historical input vector, i be the i-th target object, t be the current calculation cycle, and t-1 be the previous historical calculation cycle.

[0008] Optionally, the step of dividing each target object into a corresponding solution channel based on a preset sparse infinitesimal threshold and an adaptive threshold includes: When the changing vector Satisfy sparsity constraints And satisfy the amplitude constraint Each target object is assigned to a sparse, sensitivity-based, test-free path. Computing devices identify input change vectors Non-zero-dimensional sets, based solely on cache sensitivity matrix Read from Columns, perform sparse weighted vector addition: The implicit parameter estimate is calculated using formula (2); Formula (2); In the formula, These are the estimated values ​​of the hidden parameters. This represents the estimated value of the latent parameters of the i-th cell in the previous period. For the changing vector, Let be the first-order partial derivative of the j-th dimension input variable with respect to the latent parameter. When the target object is assigned to the sparse sensitivity-free path, the output is the estimated value of the latent parameter.

[0009] Optionally, the step of dividing each target object into a corresponding solution channel based on a preset sparse infinitesimal threshold and an adaptive threshold includes: When the changing vector The norm satisfies If the triggering conditions for the sparse sensitivity exemption path are not met, each target object will be assigned to the incremental extrapolation verification path. Computing devices utilize cache sensitivity matrix Perform full matrix-vector multiplication: The initial guess value for iteration is calculated using formula (3); Formula (3); In the formula, The initial guess value for iteration is output when the target object is assigned to the incremental extrapolation verification path.

[0010] Optionally, the step of dividing each target object into a corresponding solution channel based on a preset sparse infinitesimal threshold and an adaptive threshold includes: when or target object When there is no valid historical state, each target object is assigned to the full solution path.

[0011] Optionally, the step of performing a finite number of Newton correction iterations starting from a pre-constructed approximate function table or an initial guess for iteration includes: Based on the initial guess value Starting from this point, the computing device executes at most... Step Newton correction iteration: The new implicit parameters are calculated using formula (4); Formula (4); In the formula, These are the newly obtained implicit parameters after a round of Newtonian corrections. This is the current estimate of the hidden parameters. Let f be the first-order partial derivative of the function f with respect to the parameter p. Output the target value; After each step, the current residual is calculated. If the residual meets the accuracy tolerance, the iteration is terminated early, without having to execute to the upper limit. This step is to avoid unnecessary computational overhead; Iterative convergence to Then, the computing device uses the Jacobian inverse matrix already computed in the final iteration step. and numerical differentiation Calculate and cache the sensitivity matrix: The sensitivity matrix is ​​calculated using formula (5); Formula (5); In the formula, For the sensitivity matrix, It is the Jacobian inverse matrix. It is a numerical differential.

[0012] Optionally, the automatic adjustment of the adaptive threshold based on the average posterior error includes: The computing device will average the residuals With preset upper bound and preset lower bound Compare and perform adaptive threshold updates: like Then the current adaptive threshold The estimate is too conservative, the incremental effective domain is underestimated, and the computing device needs to be expanded. This allows more target objects to undergo incremental extrapolation verification in the next cycle; like This indicates that the error accumulation exceeds the acceptable range, the incremental effective domain estimate is too large, and the computing device is underutilized. Meanwhile, objects with excessive residuals in this period are marked as mandatory full solutions for the next period to ensure that the solution accuracy does not gradually deteriorate due to continuous incremental paths; like The threshold remains unchanged.

[0013] A streaming real-time solution system for nonlinear equations based on sensitivity caching and vectorized bucketing includes: The preprocessing module is used to collect the original input data of each target object in the current batch, normalize the original input data to obtain the current input vector of each target object, retrieve the historical input vector of each target object in the previous period, and obtain the change vector of the current input vector relative to the historical input vector through vector difference operation. The channel-based flow determination module is used to divide each target object into a corresponding solution channel based on a preset sparse infinitesimal threshold and an adaptive threshold. The solution channel includes a sparse sensitivity-free path, an incremental extrapolation verification path, and a full solution path, and outputs the corresponding implicit parameter estimates or iterative initial guesses. The iterative solution module is used to perform a finite number of Newton correction iterations on target objects that fail the verification of the split-to-full-solution path and the incremental extrapolation verification path, starting with a pre-built approximate function table or the initial guess value of the iteration. After the iteration converges, the sensitivity matrix is ​​pre-calculated and cached. The adaptive feedback module is used to summarize the solution results and solution residuals of each target object in the current batch, and to calculate the average posterior error of all target objects under the incremental path based on the solution results and solution residuals. Based on the average posterior error, the adaptive threshold is automatically adjusted, and the historical state quadruples are updated in a differentiated manner according to the solution channel to which the target object belongs, thus building a cross-period adaptive feedback link. The hardware parallel scheduling module is used to perform parameter similarity-aware hash bucketing, state quadruple-guided memory layout transformation, and path-aware vectorized dual-stream parallel scheduling on each target object in the current batch, efficiently mapping the full solution task to the hardware execution unit.

[0014] An electronic device includes a memory, a processor, and a computer program stored in the memory and running on the processor, wherein the processor executes the computer program to implement the steps of the method described herein.

[0015] A non-transitory computer-readable storage medium having a computer program stored thereon, the computer program implementing the steps of the method when executed by a processor.

[0016] The present invention has the following advantages: This invention utilizes a change vector to achieve differentiated path routing for target objects, constructing a three-level solution channel. It directly reuses sensitivity information to output results for sparse, infinitely variable samples, significantly reducing the number of full Newton iterations and high-overhead computations such as Jacobian matrix inversion, effectively lowering end-to-end latency in streaming solutions and adapting to millisecond-level high-frequency data processing requirements. After iterative convergence, the invention caches the sensitivity matrix and dynamically adjusts the threshold using a cross-cycle adaptive feedback link, differentially updating historical state quadruples to achieve efficient reuse of intermediate states. This eliminates a large amount of redundant floating-point operations and memory read / write overhead, significantly improving computational resource utilization. Simultaneously, this invention reduces hardware thread forking and memory access losses through parameter similarity hashing, state-guided memory layout transformation, and path-aware vectorized dual-stream scheduling, fully releasing the vectorized parallel computing power of the CPU and GPU. These technical features are coupled to form a synergistic effect, significantly improving the real-time performance and throughput of streaming solutions for batches of nonlinear equations while ensuring controllable solution accuracy. Attached Figure Description

[0017] For illustrative and not limiting purposes, the present invention will now be described in conjunction with embodiments and accompanying drawings, wherein: Figure 1 This is a flowchart illustrating the real-time streaming solution method for nonlinear equation systems based on sensitivity caching and vectorized bucketing in an embodiment of the present invention. Figure 2 This is a schematic diagram of the main components of the nonlinear equation system based on sensitivity buffering and vectorized bucketing in an embodiment of the present invention. Figure 3 This is a flowchart of the adaptive threshold update method in step S104 of this embodiment of the invention; Figure 4 This is a flowchart of the method for the quadruple classification and write-back strategy in step S104 of this invention. Figure 5 This is a block diagram of the hardware system device in an embodiment of the present invention; Figure 6 This is a timing diagram of the parallel execution pipeline of the hardware system in an embodiment of the present invention; Figure 7 This is a schematic diagram of the physical structure of the electronic device provided by the present invention. Detailed Implementation

[0018] To enable those skilled in the art to better understand the present invention, 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 a part of the embodiments of the present invention, and not all of them. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort should fall within the scope of protection of the present invention.

[0019] It should be noted that the terms "first," "second," etc., in the specification and accompanying drawings of this invention are used to distinguish similar objects and are not necessarily used to describe a specific order or sequence. It should be understood that such data can be used interchangeably where appropriate for the embodiments of the invention described herein. Furthermore, the terms "comprising" and "having," and any variations thereof, are intended to cover non-exclusive inclusion; for example, a process, method, system, product, or apparatus that comprises a series of steps or units is not necessarily limited to those steps or units explicitly listed, but may include other steps or units not explicitly listed or inherent to such processes, methods, products, or apparatus.

[0020] It should be noted that, where there is no conflict, the embodiments and features of the present invention can be combined with each other. The embodiments of the present invention will now be described in detail with reference to the accompanying drawings.

[0021] Figure 1 This is a flowchart illustrating the real-time streaming solution method for nonlinear equation systems based on sensitivity caching and vectorized bucketing in an embodiment of the present invention. Figure 1 As shown, the real-time streaming solution method for nonlinear equations based on sensitivity caching and vectorized bucketing provided in this embodiment of the invention includes the following steps S101 to S105.

[0022] S101: Collect the original input data of each target object in the current batch, normalize the original input data to obtain the current input vector of each target object, retrieve the historical input vector of each target object in the previous period, and obtain the change vector of the current input vector relative to the historical input vector through vector difference operation.

[0023] The raw input data (hereinafter referred to as "first information") for each target object in the current batch comes from the streaming push of the external data interface. Each push constitutes a batch, and the batch contains The original input data for each target object. Different target objects belong to different model types, and their original input dimensions and value ranges also differ. Therefore, a unified normalization process must be performed before proceeding to subsequent processing.

[0024] In this embodiment, the computing device processes each target object in the first information. Perform affine normalization on the original input to obtain a normalized input vector. This compresses the numerical range of each dimension to a preset interval (e.g., Alternatively, a standardized interval centered on the historical mean can be used. Normalization parameters (mean, scale factor) are estimated offline based on historical distributions, and scalar multiplication and addition operations are performed at runtime, with negligible computational overhead. The purpose of the normalization process is to eliminate the influence of different dimensions on the subsequent numerical stability of the Jacobian matrix and to maintain a balanced geometry of the incremental effective field in all dimensions, avoiding threshold judgment failure due to differences in dimensions.

[0025] In this embodiment, the computing device reads the object from the state management module. The historical state quadruple stored in the previous cycle (hereinafter referred to as "historical state information"): in, For object The input vector was normalized in the previous cycle; This is the result of solving the implicit parameters of the previous cycle; This is the Jacobian matrix of the model function with respect to the latent parameters at the convergence point of the previous cycle; This is the sensitivity matrix pre-calculated and cached after convergence in the previous cycle. For its meaning and calculation method, please refer to step S103.

[0026] In this embodiment, when the system is running for the first time or an object enters the system for the first time, there is no corresponding historical state quadruple in the state management module. The computing device marks the object as "no historical state" and directly routes it to the full solution path (path three) in the subsequent step S102 to obtain the first valid historical state of the object.

[0027] In this embodiment, the computing device calculates the input change based on the difference between the current normalized input vector and the historical normalized input vector: The input change The sparsity and norm are the core criteria for performing three-level path assignment in step S102. In streaming real-time scenarios, It typically exhibits a highly sparse structure, triggering vector changes in only a small number of dimensions.

[0028] This step outputs the normalized input vector. Input change Historical state quadruple This serves as the input information for step S102 (hereinafter referred to as "second information"). Compared to the first information, the second information has completed the unification of dimensions and the association with historical states, and adds information representing the magnitude and structure of changes in the current period. The components provide a complete decision-making basis for subsequent path assignment.

[0029] S102, based on the preset sparse infinitesimal threshold and adaptive threshold, divides each target object into the corresponding solution channel. The solution channel includes the sparse sensitivity verification path, the incremental extrapolation verification path and the full solution path, and outputs the corresponding implicit parameter estimate or the initial guess value of the iteration.

[0030] In this embodiment, step S102 receives the second information and the current adaptive threshold dynamically maintained across cycles by step S104. Based on the following three-level path dispatch mechanism, each target object within a batch is routed sequentially (hereinafter referred to as "path dispatch information"). The theoretical basis of the three-level path dispatch is the implicit function theorem: if the model function... The convergence point of the previous cycle Continuously differentiable at point and Jacobian matrix If not singular, then in There are smooth implicit functions in the neighborhood. ,satisfy And its relation to The derivative satisfies: The theorem guarantees that when the input variation is sufficiently small, the sensitivity matrix... Performing first-order linear extrapolation yields a bounded approximate solution without requiring iterative solutions.

[0031] In this embodiment, the computing device defines the incremental effective field based on the implicit function theorem, which represents the set of inputs whose approximation error satisfies the accuracy tolerance after performing linear extrapolation in a cached state: when When using linear extrapolation results as estimates of the implicit parameters for the current period, accuracy is crucial. Acceptable in the sense of the word; when When necessary, the Newton iterative solver must be activated. The introduction of the incremental effective field transforms the judgment of "whether iterative solution is needed" from performing residual checks at each step to making a prior judgment on the magnitude and structure of input changes, which is the core mechanism of this application to reduce invalid computation.

[0032] In this embodiment, the three-level path in step S102 is as follows: The trigger condition for Path 1 (Sparse Sensitivity-Free Path) is: Input change vector Satisfy sparsity constraints And satisfy the amplitude constraint .in, express The absolute value exceeds the numerical noise threshold. The number of components; Set a preset upper limit for sparsity; To preset a sparse infinitesimal threshold, satisfying During the offline calibration stage, based on The local Lipschitz constant is predetermined.

[0033] The computing device identifies objects that meet the triggering conditions of path one. China and Africa zero-dimensional set From the cache sensitivity matrix alone Read from Columns, perform sparse weighted vector addition: By estimating the second-order remainder term through the first-order extrapolation of the implicit function theorem, the above approximate result satisfies the upper bound of the error: in To and The bounded constant related to the local Lipschitz constant within the current neighborhood is pre-verified to meet accuracy tolerances during the offline calibration phase. The key innovation of Path One is that, since the upper bound of the error has been verified offline, no online residual calculations are required; the result is directly output. This is the result of the solution in this issue. For , In a typical scenario, the above calculation degenerates into a single scalar multiplication and addition, with an equivalent computational complexity of O(n log n). .

[0034] In one example, the sparse infinitesimal threshold of path one The determination method is as follows: During the offline calibration phase, using... Local Lipschitz constant and required precision tolerance As input, let The inverse solution yields The local Lipschitz constant L and error coefficient C are estimated during the offline calibration stage as follows: in the prior feasible region of the implicit parameters... A number of uniformly sampled points are used within the typical distribution domain, and finite difference calculations are performed at each sampling point. about The first-order partial derivative of L is taken as the maximum spectral norm of L on the sample set.

[0035] The trigger condition for path two (incremental extrapolation verification path) is: the norm of the input change vector satisfies... And it does not meet the triggering conditions of path one, that is For dense vectors (the number of non-zero components exceeds...) ), or the range of change exceeds But it is still within the adaptive threshold. Within the defined incremental effective domain.

[0036] For objects that meet the triggering conditions of path two, the computing device utilizes the cache sensitivity matrix. Perform full matrix-vector multiplication: The computational complexity is Subsequently, local residual estimates were calculated online. If the accuracy tolerance is met, then output directly. This will be the result of the solution in this period; if it exceeds the accuracy tolerance, then... As a high-quality initial guess, it is submitted in step S103 with a downgrade flag to perform a small number of correction iterations. Compared to path one, path two requires online residual verification, but because... The solution is close to the true solution. When downgrading to step S103, the number of iterations required is usually 1 to 2, which is much lower than the 8 to 30 steps required for a full solution.

[0037] The triggering condition for path three (full solution path) is: That is, the current input exceeds the incremental valid domain; or the object There is no valid historical state (either the first solution or the historical state has expired). Objects that meet the above conditions are directly submitted to step S103 for processing with a full solution identifier, and step S102 does not perform any estimation calculations.

[0038] This step outputs the following information (hereinafter referred to as "path assignment information"): The solution results for the verified objects of path one and path two. ; Initial guess values ​​for path 2 downgrade and path 3 objects (or null) and path identifier. The path identifiers of all target objects are synchronously passed to step S105 for parallel scheduling.

[0039] S103: For target objects that fail the verification of the full solution path and the incremental extrapolation verification path, a finite number of Newton correction iterations are performed starting from the pre-constructed approximate function table or the initial guess value of the iteration. After the iteration converges, the sensitivity matrix is ​​pre-calculated and the caching is completed.

[0040] In this embodiment, step S103 receives the object to be solved (full / corrected) submitted in step S102, and the current normalized input passed in in step S101. It performs a finite number of Newton correction iterations and outputs the exact solution results and the updated state parameters (hereinafter referred to as "exact solution information").

[0041] In this embodiment, the computing device obtains the initial guess value in step S103 as follows: For the first solution of path three or objects with significant changes, the computing device has already obtained the initial guess value based on the implicit parameter prior feasible region in the offline stage. and Preconstructed approximate function table for typical distribution domains , so that for any Table lookup results If the deviation from the true solution is within a reasonable range, the approximate function table can be implemented using multidimensional linear interpolation or piecewise constant quantization. The offline construction method of the approximate function table T is to grid the distribution domain of X, iterate node by node to obtain the exact solution and store it as an "input → solution" mapping table, and obtain the initial value by interpolation online.

[0042] In this embodiment, the initial guess value is used. Starting from this point, the computing device executes at most... Step Newton correction iteration, where The upper limit is preset, typically ranging from 2 to 5. The implicit parameter estimate is updated at each iteration using the following formula: After each step, the current residual is calculated. If the residual meets the accuracy tolerance, the iteration is terminated early, without having to execute to the upper limit. This step is to avoid unnecessary computational overhead.

[0043] In this embodiment, the iteration converges to Then, the computing device uses the Jacobian inverse matrix already computed in the final iteration step. and numerical differentiation Calculate and cache the sensitivity matrix for this period: Sensitivity matrix The physical meaning of is: its first column vector Indicates the first When the input dimension changes by one unit, the hidden parameters The first-order approximate change is guaranteed by the implicit function theorem to hold within the input neighborhood. The pre-calculation of the sensitivity matrix fully reuses the matrix inversion operations already performed in this iteration. It only adds one matrix multiplication, does not introduce additional matrix inversion overhead, and its storage cost is low. It is far less expensive than storing the complete iteration history.

[0044] This step outputs precise solution information, including: the results of solving the implicit parameters for this period. Corresponding residuals Jacobian matrix Sensitivity matrix . The results, along with the outputs of path one and path two in step S102, are combined and passed to step S104.

[0045] S104, summarize the solution results and solution residuals of each target object in the current batch, calculate the average posterior error of all target objects under the incremental path based on the solution results and solution residuals, automatically adjust the adaptive threshold based on the average posterior error, update the historical state quadruple according to the solution channel to which the target object belongs, and build a cross-cycle adaptive feedback link. like Figure 3 As shown, in this embodiment, step S104 receives the solution results and residuals of all target objects in the current cycle, performs error statistics and threshold updates, completes the cross-cycle state cache write-back, and outputs the updated adaptive control parameters and state cache (hereinafter referred to as "feedback control information").

[0046] In this embodiment, the computing device summarizes the set of objects that follow path two (incremental extrapolation verification path) in the current period. Calculate its mean posterior residual: residual of the path 2 object The results have been calculated and recorded online in step S102, and summarized directly in step S104 without additional model evaluation. The residuals of the path one object are not included in the online statistics because the offline error bounds already meet the accuracy tolerance. The residuals of the path three object reflect the convergence quality of the full solution and are processed separately in step S103. The residual distribution of path two directly reflects the effectiveness of the incremental effective domain and is the most informative statistic driving the adaptive threshold update.

[0047] In this embodiment, the computing device will average the residual. With preset upper and lower bounds , (satisfy Compare and perform adaptive threshold updates: like This indicates the current adaptive threshold. The estimate is too conservative, the incremental effective domain is underestimated, and the computing device needs to be expanded. This allows more objects to follow path two in the next cycle, improving overall computational efficiency; like This indicates that the error accumulation exceeds the acceptable range, the incremental effective domain estimate is too large, and the computing device is underutilized. Meanwhile, objects with excessive residuals in this period are marked as mandatory full solutions for the next period to ensure that the solution accuracy does not gradually deteriorate due to continuous incremental paths; like The threshold remains unchanged.

[0048] The adaptive update function Satisfies monotonicity constraint: Under the condition that the statistical properties of the input sequence are stationary, Converging to the optimal threshold that maximizes the coverage of path two while satisfying the overall accuracy constraint. No manual intervention is required. The update function... The threshold is increased or decreased geometrically by applying a multiplicative adjustment based on the posterior error, with a boundary truncation. This makes the threshold monotonic with respect to the error (the larger the error, the stronger the threshold contraction) and bounded. Thus, when the input is stationary, it converges to the optimal threshold that maximizes the coverage of path two without violating the accuracy constraint. .

[0049] like Figure 4 As shown, in this embodiment, the computing device performs a categorized write-back of the current state quadruple, and the write-back strategy is executed differently based on the solution path: Path three objects: with complete new quadruple Write the overwrite to the state cache, and all fields are the latest calculated values ​​after the convergence of the current Newton iteration; Path 1 / Path 2 objects: partially update the quadruple The write operation only updates the input vector and implicit parameter components, while keeping the previous Jacobian matrix and sensitivity matrix unchanged. This avoids the risk of writing false Jacobian information and polluting the path assignment basis for the next cycle when there is no full solution support.

[0050] This step outputs feedback control information, including: the updated adaptive threshold. (Passed to the next cycle step S102); Forced full solution trigger flag set; Updated state cache (for the next cycle step S101 to read), forming a complete cross-cycle feedback loop.

[0051] S105 performs parameter similarity-aware hash bucketing, state quadruple-guided memory layout transformation, and path-aware vectorized dual-stream parallel scheduling on each target object in the current batch, efficiently mapping the full solution task to the hardware execution unit.

[0052] In this embodiment, step S105 is responsible for efficiently mapping the solution task of multiple target objects within a batch to a hardware execution unit (such as...). Figure 5 As shown in the figure, this step includes three functional sub-units, which sequentially complete vectorized bucketing, memory transformation, and parallel scheduling.

[0053] Subunit 1: Convergence Consistency-Aware Hash Bucketing. The computing device performs hash bucketing on all target objects within a batch, based on the normalized input vector. Perform Locality Sensitive Hash (LSH) bucketing: in This is the hyperparameter of the bucket radius. The theoretical basis of the bucket division scheme is: if By the implicit function theorem, it can be deduced that the corresponding Jacobian matrix satisfies ( for The local Lipschitz constant), and thus the difference in the number of convergence steps of the Newton iteration for objects in the same bucket is bounded: By appropriate selection This allows for more consistent iteration steps among objects within the same bucket (the consistency of convergence steps among objects within the same bucket is contingent upon the multi-level path assignment completed in step S102 – path assignment ensures that objects within the same bucket either follow the same fast path or the same full path; only then can similarity-based bucketing effectively group objects that converge synchronously; without this prior assignment, objects with vastly different convergence steps will be mixed into the same bucket, increasing the forking rate instead of decreasing it), significantly reducing the Warp Divergence problem, and ensuring that most threads within the Warp complete computations with similar numbers, bringing hardware execution efficiency close to the theoretical peak. The number of objects in each bucket is determined by the hardware vector width. Round up to the nearest whole number, if insufficient The buckets are filled with virtual placeholder objects to ensure that each vectorized instruction is executed at full capacity.

[0054] Subunit Two: State Quadruple-Oriented Memory Layout Transformation. The computing device performs a memory layout transformation on the state quadruple data within each bucket after bucketing, changing the layout from object-first (Array of Structures, AoS) to dimension-first (Structure of Arrays, SoA). This layout transformation is achieved by continuously writing all object data of the same parameter dimension into an alignment buffer in dimension-first order during the data packing stage, such that: (1) For the full path batch submitted to the GPU execution flow, the transformed SoA data is asynchronously transferred to the GPU memory by the DMA engine in a continuous transfer manner. The GPU kernel function directly loads the data in a vectorized manner to meet the cache line alignment, without the need to perform additional transpose operations on the GPU side; (2) For incremental path batches that reside in the CPU execution flow, the computing device completes dimension-first access in-situ during the vector register loading stage through SIMD aggregation instructions, which is equivalent to layout transformation without materializing intermediate copies.

[0055] The layout transformation and the bucket hash operation of sub-unit one are integrated into the same data traversal, and the DMA transfer operation and the CPU-side operation are asynchronous and parallel, so the data transfer delay is basically hidden in the bucket and packing calculation delay.

[0056] In this embodiment, the computing device simultaneously calculates the approximate mean of the sensitivity matrix within the bucket: It has been proven from sub-unit one that the Jacobian matrix structure within the same bucket is similar, therefore Broadcast reuse is possible among objects within the bucket, reducing the storage size of the sensitivity matrix for incremental paths from... Down to The approximation error is controlled within the accuracy tolerance range by the Lipschitz bound. The above data rearrangement and mean calculation are completed asynchronously by the DMA engine during the CPU execution of the bucketing logic. The data transfer delay is basically hidden in the bucketing calculation delay, without introducing additional serial overhead.

[0057] Subunit 3: Path-aware vectorized parallel execution. The computing device receives batch data in SoA format and the in-bucket mean sensitivity matrix output from subunit 2. And the path identifiers of each object, performing path separation and dual-stream parallel scheduling: Incremental Path Batch (Path 1 / Path 2 Objects): Aggregates objects within a batch that follow Path 1 or Path 2 into an incremental batch, broadcasting the average sensitivity matrix within the multiplexed bucket. Perform vectorized linear extrapolation The entire incremental batch only requires one matrix mean addition. After matrix-vector multiplication, the SIMD instruction utilization rate is close to the theoretical peak. Full path batch (path 3 objects): Submit objects that follow path 3 to the vectorized Newton iteration kernel function by bucket. Since sub-unit 1 has already guaranteed the similarity of inputs within the same bucket, there are no conditional branches in the kernel function, which significantly reduces the bifurcation rate.

[0058] like Figure 6 As shown, the path-aware dual-stream parallel execution subunit splits objects within the same batch into two types of heterogeneous execution streams according to their path identifiers: incremental path batches (path one / two objects) are submitted to the CPU-side SIMD execution stream, and full path batches (path three objects) are submitted to the GPU-side CUDA (Compute Unified Device Architecture) Stream execution stream. The two types of execution streams run synchronously and in parallel on the CPU and GPU, respectively.

[0059] This step outputs a set of implicit parameter solutions for a batch of target objects. The results are summarized in step S104 for residual statistics and threshold updates. The updated state quadruple of each object is written back to the state cache in step S104, completing the full-cycle closed loop.

[0060] Steps S101 to S105 constitute a complete solution cycle. When the next batch of input data arrives, the system restarts from step S101, using the adaptive threshold at this time. The state quadruples of all objects have been updated in step S104. The system's ability to respond to changes in input data characteristics continues to improve over time, thereby achieving online adaptive streaming solution.

[0061] A preferred embodiment two is as follows: This embodiment, based on the general method described in Embodiment 1, takes the real-time inversion of the state of charge (SOC) and ohmic internal resistance R0 of a massive number of cells in a power battery / energy storage system as a specific application scenario, and explains the specific implementation of each step. Processing steps that are the same as or similar to those in Embodiment 1 will not be explained in principle again in this embodiment; only the specific details will be described.

[0062] The model function in this embodiment This is a set of nonlinear equations based on the equivalent circuit of a battery cell and temperature correction. Given the current observable parameter vector of a certain battery cell... ,in The current terminal voltage (in V). This represents the current current (discharge is positive, unit: A). Cell temperature (in °C). , The terminal voltage and current of the previous sampling period; implicit parameters For the quantity to be inverted, among which State of charge (SOC) is dimensionless and ranges from 0 to 1. Let R0 be the internal resistance in ohms (unit: mΩ). In this embodiment, n=2 (two-dimensional implicit parameter), m=5 (five-dimensional observable input), and k=2 (two-dimensional equality constraint) form a matrix nonlinear equation system.

[0063] The model function is defined as follows: Under the assumption that the state of charge and internal resistance remain approximately constant at two adjacent sampling times, the terminal voltage must simultaneously satisfy the equivalent circuit balance at both times, resulting in two equality constraints: The open-circuit voltage (OCV) is a strongly nonlinear function of the state of charge. It is calibrated segmentally according to the charge interval during the offline calibration phase. A representative analytical form is as follows: In the formula The reference electromotive force (unit: V). This is the temperature coefficient (unit: V / °C). Reference temperature (unit: °C) The slope of the platform segment (in V). This is the end correction amplitude (in V). The term represents the end steepness coefficient (dimensionless); this form exhibits an exponential steep change at both ends of the charged region and a piecewise near-linear plateau characteristic in the middle. There is no closed-form inverse solution; numerical iteration is required. The polarization resistance varies with temperature according to the Arrhenius relation. ,in It is the pre-exponential factor (unit: mΩ). Apparent activation energy (unit: J / mol). The value is the gas constant (8.314 J / (mol·K)). All the above coefficients were determined during the offline calibration stage and were directly taken during runtime.

[0064] The objective constraint is That is, the model-predicted terminal voltage equals the measured terminal voltage, and the required voltage is... This characterizes the current true state of charge and ohmic internal resistance of the battery cell. The model function in this embodiment includes both exponential terms (OCV end correction and polarization resistance Arrhenius term) and piecewise nonlinear terms (OCV piecewise calibration), exhibiting a typical strongly nonlinear structure. This is particularly relevant in the presence of current excitation (…). Under typical operating conditions, Jacobian functions are non-singular and have a unique solution, satisfying the applicable conditions of the implicit function theorem.

[0065] Specific implementation of step S101 in this embodiment In this embodiment, the computing device receives the current batch push data from the acquisition interface of the Battery Management System (BMS). Each push constitutes a batch, and the batch contains... The original samples of each individual cell (typically ranging from a single cluster to an entire group of thousands or even tens of thousands of cells). The computing device analyzes each cell... Perform affine normalization on the original input to obtain a normalized input vector. :right Linear mapping of the cell's rated voltage range to... Normalized to the rated current, for Normalization is performed based on the operating temperature range. The normalization parameters are estimated based on cell specifications during the offline stage, and only scalar multiplication and addition are performed during runtime, with negligible overhead. The purpose is to eliminate the influence of the differences in voltage, current, and temperature dimensions on the stability of the Jacobian numerical value, and to make the geometry of the incremental effective domain balanced in all dimensions.

[0066] In this embodiment, the computing device reads the battery cell data from the status management module. The historical state quadruple stored in the previous cycle ,in The state of charge and internal resistance obtained from the previous inversion; This is the Jacobian matrix of the model function with respect to the latent parameters at the convergence point of the previous period; This is the sensitivity matrix pre-calculated and cached after the previous convergence. Its meaning and calculation method are detailed in step S103. For the first time of grid connection of a battery cell or a newly installed battery cell, there is no corresponding historical quadruple in the state management module. The computing device marks the battery cell as "no historical state" and directly routes it to the full solution path (path three) in step S102.

[0067] In this embodiment, the computing device calculates the input change. Under steady-state operation with constant or near-constant current, the temperature is constrained by the thermal inertia and electrochemical relaxation of the battery cell. The current remains almost constant between adjacent millisecond-level samples, while the variation is gradual, primarily due to minute changes in the terminal voltage caused by polarization relaxation. Typically exhibiting a highly sparse structure, with only minor changes in the terminal voltage dimension and its historical shift dimension, satisfying the sparsity constraint of path one. This step outputs... , , This serves as the input for step S102.

[0068] Specific implementation of step S102 in this embodiment In this embodiment, the computing device performs routing for each battery cell based on the three-level path allocation mechanism described in Embodiment 1. The theoretical basis of the three-level path is the implicit function theorem: when It is continuously differentiable at the convergence point in the previous period. In the non-singular case, there exists a smooth implicit function. satisfy This ensures that a bounded approximate solution can be obtained by linear extrapolation of the sensitivity matrix when the input changes slightly. In this embodiment, the inverse analytical expression of the 2×2 Jacobian is given: in When there is current excitation ( )hour Jacobian invertible. Sensitivity matrix. , its first List of first The latent parameter vector when the input dimension changes by one unit The first-order approximate change. The third-level path is as follows: The triggering condition for Path 1 (Sparse Sensitivity-Free Path) is: (Under the steady-state condition of this embodiment, the current push only causes a slight change in the terminal voltage.) Take 1~2) and .in To preset a sparse infinitesimal threshold, satisfying The determination is based on the local Lipschitz constant of the OCV function during the offline calibration stage. Cells meeting the conditions are identified by the computing device. China and Africa zero-dimensional set From the cache sensitivity matrix alone Read the corresponding column and perform sparse weighted vector addition: The second-order remainder estimate obtained by first-order extrapolation using the implicit function theorem approximates a result that satisfies the upper bound of the error. The error bound is pre-verified to meet accuracy tolerance during the offline calibration phase. The key innovation of Path One is that the upper error bound is verified offline, eliminating the need for any online residual calculations and allowing for direct output. The equivalent computational complexity degenerates to O(n) = O(2) scalar multiplication and addition, and the time delay is negligible.

[0069] The triggering condition for Path Two (Incremental Extrapolation Verification Path) is: Furthermore, it does not meet the conditions of path one, typically in scenarios where temperature rise and current change synchronously (such as rate switching or ambient temperature drift). This is a dense vector. The computing device reads the complete sensitivity matrix. Perform matrix-vector multiplication The complexity is O(nm) = O(10), followed by online calculation of the residuals. If the standard is met, output directly; otherwise, output as specified. To downgrade the high-quality initial value, perform 1-2 steps of correction in step S103.

[0070] The triggering condition for path three (full solution path) is: (Such as charging / discharging state switching, pulsed high current, sudden change in cell charge), or the cell has no valid historical state (first time entering the grid or forced full quantity marked in the previous period). For Path 3 cells, directly submit to step S103; this step does not perform estimation calculations. This step outputs the inversion results of Path 1 and Path 2 verified cells. The initial guess values ​​and path identifiers for the downgraded cells in path two and the cells in path three are also provided. The path identifiers are synchronously transmitted to step S105 for parallel scheduling.

[0071] Specific implementation of step S103 in this embodiment In this embodiment, step S103 performs matrix Newton iteration on the full / corrected battery cells. For the first-time grid-connected battery cell in path three, the computing device performs calculations based on the prior feasible region of the state of charge during the offline phase. Pre-constructed approximate function table with typical internal resistance distribution domain (This can be achieved using multidimensional linear interpolation or piecewise constant quantization), and high-quality initial values ​​can be obtained by online table lookup. For the degraded cells in path two, the output from step S102 is directly used. This is the initial value. Execute up to the starting point Step (typically 2~5) matrix Newton iteration: Each step reuses the aforementioned 2×2 Jacobian analytic inverse; the iteration terminates early when the residual reaches the accuracy tolerance. Iteration converges to... Then, the computing device uses the data obtained in the final step. and numerical differentiation Calculate and cache the sensitivity matrix: in Analysis of each component yields: , , , , The remaining components are given as zero or symmetric. The pre-computation of the sensitivity matrix completely reuses the matrix inversion operation already completed in this iteration, adding only one matrix multiplication and introducing no additional inversion. The storage cost O(nm) is much lower than storing the iteration history. This step outputs the current period's... residual Jacobian Sensitivity matrix .

[0072] Specific implementation of step S104 in this embodiment In this embodiment, the computing device executes steps S101 to S105 cyclically according to the sampling frequency during the BMS runtime. Step S104 summarizes the set of cells that have traveled along path two in this cycle. Calculate the average posterior residuals , and preset upper and lower boundaries , ( Comparison: If This indicates that the threshold is too conservative and should be expanded. To allow more battery cells to use path two; if This indicates that the error accumulation has exceeded the limit and the contraction has occurred. Cells with excessive residuals are marked for forced full solution in the next cycle to ensure that the inversion accuracy is not degraded by continuous incremental paths during periods of high-rate charging and discharging or drastic temperature changes; if it is between the two, it is maintained.

[0073] In this embodiment, the state cache is written back according to the path: the path of three-cell battery cells is written back with a complete new quaternion. Overwrite; Path 1 / Path 2 cells partially update the quaternion. The write operation only updates the input and implicit parameter components, retaining the previous Jacobian and sensitivity matrices. This avoids the risk of writing false Jacobian information and contaminating the path assignment basis for the next cycle when there is no full solution support. This step outputs the updated... Force a full trigger on the set of identifiers and update the state cache to form a cross-cycle feedback loop.

[0074] Specific implementation of step S105 in this embodiment In this embodiment, step S105 is responsible for efficiently mapping the inversion task of a large number of battery cells in a batch to the hardware execution unit, which includes three functional sub-units.

[0075] Subunit 1: Convergence Consistency Aware Hash Bucketing. The computing device performs hash bucketing on all cells within a batch, based on the normalized input vector. Perform Locality Sensitive Hash Bucketing , This refers to the bucket radius hyperparameter. The bucket division in this embodiment has a clear physical basis: cells within the same module, with similar charging ranges, temperatures, and aging levels have similar OCV slopes. With polarization internal resistance Similar values ​​correspond to similar Jacobian matrix structures, hence... It can be deduced Furthermore, the difference in the number of Newtonian convergence steps between the same battery cell and the others is bounded. Therefore, cells under the same physical conditions are naturally mapped to the same bucket and converge with a consistent number of steps, significantly reducing GPUWarp thread forking and allowing most threads within the Warp to complete calculations with the same number of steps. Each bucket is based on the hardware vector width. Align upwards, and fill any gaps with virtual placeholders to ensure that vectorized instructions are executed at full capacity.

[0076] Subunit 2: State Quadruple-Driven Memory Layout Transformation. The computing device performs a memory rearrangement from Object-Oriented Layout (AoS) to Dimension-Oriented Layout (SoA) on the state quadruple data within each bucket after bucketing. This ensures that all cell data for the same parameter dimension are written continuously to the alignment buffer, meeting the SIMD full-bandwidth loading requirement of cache line (64 bytes) alignment. For full path batches submitted to the GPU execution flow, the transformed SoA data is asynchronously transferred to GPU memory by the DMA engine in a continuous transfer manner, and the kernel function directly loads the aligned data. For incremental path batches residing in the CPU execution flow, dimension-oriented access is completed locally during the vector register loading stage using SIMD aggregation instructions, without the need for materializing intermediate copies. Simultaneously, the mean of the sensitivity matrix within each bucket is calculated. Broadcast multiplexing is performed among the cells within the bucket, reducing the required sensitivity storage for incremental paths from... Down to By bucket size For example, the storage requirement is reduced to 1 / 32 of the original, significantly reducing memory usage and data transfer overhead. The above layout transformation and the bucket hashing of sub-unit one are integrated into the same data traversal. DMA transfer and CPU-side computation are asynchronous and parallel, and the transfer latency is basically hidden within the bucket calculation latency.

[0077] Subunit 3: Path-aware vectorized dual-stream parallel execution. The computing device distributes objects within the current batch according to path identifiers to two types of heterogeneous execution streams for parallel scheduling: incremental path batches (path one / path two cells) are submitted to the CPU-side SIMD execution stream and broadcast multiplexed. Perform vectorized linear extrapolation The SIMD instruction utilization is close to the theoretical peak. The full path batch (three-cell path) is moved to GPU memory via DMA and then submitted to the GPU-side CUDAStream execution flow, executing a vectorized Newton iterative kernel function with unconditional branches. Since sub-unit one has already guaranteed input similarity within the same bucket, the intra-kernel branching rate is significantly reduced. The two types of execution flows run synchronously and in parallel on the CPU and GPU respectively, without blocking each other. The incremental batch is usually completed before the full batch, and its remaining time window is used to prefetch the state cache for the next batch. This step outputs a set of implicit parameter inversion results for the batch of cells.

[0078] Beneficial effects of Example 2 Example 2 runs on an embedded battery domain controller / energy storage management unit with limited computing power and power consumption. Its technical effects are based on the internal performance indicators of the computer system: Under steady-state conditions, path 1 coverage is high, with most cells completing inversion using O(n)-level scalar operations, significantly reducing the utilization rate of the domain controller's central processing unit / graphics processor; the sensitivity matrix cross-cycle caching allows the 2×2 Jacobian matrix inversion to be triggered only once during full solution, with subsequent multi-cycle reuse at near-zero cost, reducing redundant floating-point operations and memory read / write operations; the state quadruple AoS→SoA rearrangement improves memory bandwidth utilization efficiency; bucket average... Broadcast multiplexing reduces memory and cache usage; convergence-aware bucketing reduces GPUWarp thread forking rate; asynchronous DMA transfer reduces input / output wait times. These hardware-level optimizations ensure that end-to-end inversion latency consistently meets millisecond-level real-time constraints, thus supporting real-time concurrent inversion of the state of charge and internal resistance of a massive number of battery cells on a single machine. This provides low-latency state input for control actions such as real-time active balancing, thermal management scheduling, overcharge and over-discharge protection, early warning of thermal runaway, and safety-linked disconnection.

[0079] Explanation of the correspondence between Example 2 and Example 1 This embodiment is a specific instance of the general method described in Embodiment 1 in the electrochemical energy storage state inversion scenario: The nonlinear equations for the equivalent circuit of the battery cell contain implicit parameters. Specifically, this is expressed as the state of charge and ohmic internal resistance. observable input Specifically, this is expressed as the terminal voltage, current, and temperature at two adjacent sampling times, with target constraints. This is specifically defined as an equality constraint where the model-predicted terminal voltage equals the measured terminal voltage. The entire processing logic of steps S101 to S105 is completely consistent with Example 1, except that... The specific function form, partial derivative analytical expression, and parameter domain range reflect the concretization of the electrochemical scenario, and this embodiment also implicitly includes parameter dimensions. The Jacobian matrix is ​​a 2×2 matrix, and the sensitivity matrix is ​​a 2×5 matrix, fully demonstrating the matrix operation process of the general method on multidimensional nonlinear equations. The method described in this embodiment is also applicable to other electrochemical / energy storage state inversion scenarios with the same abstract structure, such as online identification of equivalent circuit parameters of supercapacitors, inverse calculation of implicit parameters of fuel cell polarization curves, and real-time joint estimation of cell aging (State of Health, SOH) related parameters, which will not be listed one by one here.

[0080] A preferred embodiment three: Example 3, based on the general method described in Example 1, uses a class of strongly nonlinear single-variable equations containing multi-stage cumulative discounted cash flow (DCF) terms (represented by multi-stage discounted cash flow) as the solution object to illustrate the method's performance in terms of implicit parameters. Specific implementation under degradation conditions. This embodiment... (Single implicit parameter and single equality constraint) The model degenerates into a single-variable nonlinear equation. The processing logic of steps S101 to S105 is completely consistent with that of Embodiment 1 and Embodiment 2, except that... The specific form and dimensions are specified, so the following only describes the differences from the general method and the most representative degradation characteristics of this scenario. The same principles will not be repeated.

[0081] Given the current observable vector of the target object These are, respectively, the current market price, the base period free cash flow per share (FCF), the weighted average cost of capital (WACC), the perpetual growth rate, and the number of years in the explicit forecast period; implicit parameters. This represents the implied growth rate. The model function is a multi-stage discounted cash flow function: Target constraints This means the model output equals the given observations, and the desired result is... This refers to the implicit parameter solution that makes the model output match the given observations. Because... Jacobian degenerates into a scalar The sensitivity matrix degenerates into row vectors. Its five components represent market price, free cash flow, weighted average cost of capital, perpetual growth rate, and the effect of a unit change in the number of years in the forecast period on the implied growth rate. The first-order influence quantity.

[0082] The most representative degradation characteristic of this scenario is reflected in path one: during the trading session, financial data and macroeconomic parameters remain unchanged, only the market price... As market conditions are continuously updated, therefore Typically, only the price is nonzero ( If the path-one trigger condition is met, its sparse-weighted extrapolation degenerates into a single scalar multiplication and addition: in (Its increment is determined by the first order of the corresponding dimension sensitivity component), upper bound of error The accuracy tolerance has been verified during the offline calibration phase, eliminating the need for online residual verification. The equivalent computational complexity is [value missing]. Path Two (Multi-dimensional synchronous changes, such as those triggered by interest rate decisions) , (Variants that change with price) degenerate into the dot product of row and column vectors. ( The process involves multiple multiplication and addition, including one online residual check; Path 3 (initial inclusion, significant revision of free cash flow due to quarterly report disclosure, or being marked as a forced full entry, etc.) executes scalar Newton iteration, because... Newtonian steps degenerate into Under a lookup table hot start, convergence typically occurs in 2 to 5 steps.

[0083] During stable intraday trading sessions, price fluctuations are typically small. Path one has a coverage rate of 80%–95%, path two is approximately 3%–15%, and path three (full solution) does not exceed 5%. The vast majority of objects... Scalar operations return results, enabling concurrent real-time inverse calculations of large-scale isomorphic single-variable nonlinear equation instances on a single machine. State caches are written back according to the strategy described in Example 1: Path 3 objects are written as complete new quadruplets; Path 1 / Path 2 objects only update input and implicit parameter components, retaining the previous period's scalar Jacobian and row vector sensitivity. This example verifies the general method in... Feasibility under degenerate conditions; the same processing logic applies to the real-time streaming inverse calculation of other single-variable or multi-variable nonlinear equations with the same abstract structure, such as strongly nonlinear equations containing normal cumulative distribution terms (e.g., inverse calculation of implied volatility in Black-Scholes type), nonlinear equations containing piecewise discount terms (e.g., solving the implied yield to maturity of fixed income models), etc., which will not be listed one by one here.

[0084] A preferred embodiment four: Example 4 provides a streaming implicit parameter real-time solution device for executing the method described in Example 1. The device uses a computing server as its hardware carrier and includes, in sequence: a streaming data acquisition and state management module (corresponding to step S101, responsible for data reception, normalization, and state quadruplet reading and writing); an incremental effective domain path assignment module (corresponding to step S102, responsible for three-level path judgment and routing); a hot-start constraint iterative solution module (corresponding to step S103, responsible for Newton iteration and sensitivity matrix pre-calculation); an error-driven adaptive control module (corresponding to step S104, responsible for residual statistics, threshold updates, and state write-back); and a parameter similarity-driven vectorized parallel execution device (corresponding to step S105) that runs in parallel with the above modules. The implementation methods of the first four modules correspond one-to-one with steps S101 to S104, and will not be repeated here. The following focuses on the hardware device corresponding to step S105.

[0085] The convergence consistency-aware hash bucketing subunit is deployed on the general-purpose processor (CPU) side, and normalizes the input vector of all target objects within the batch. Perform Locality Sensitive Hash (LSH) bucketing to ensure that the input space distance does not exceed the bucket radius. Objects are grouped into the same bucket. According to the implicit function theorem, objects in the same bucket have similar Jacobian matrix structures, and the difference in the number of convergence steps in Newton's iteration is bounded (…). ), through appropriate selection This ensures that the iteration steps for objects within the same bucket are consistent, significantly reducing GPU thread forking issues. Each bucket is configured according to its hardware vector width. Alignment padding ensures that vectorized instructions are executed at full capacity.

[0086] The state quadruple-guided memory layout transformation subunit uses a direct memory access (DMA) controller as the execution entity. It performs AoS to SoA memory rearrangement on the state quadruple data within each bucket, ensuring continuous arrangement of data in the same dimension and meeting cache line (64-byte) alignment requirements, supporting full-bandwidth loading of SIMD vectorized instructions. Simultaneously, it calculates the mean of the sensitivity matrix within each bucket. Broadcasting and reusing among objects within the bucket reduces the sensitivity storage required for incremental paths from... Down to The aforementioned DMA data transfer operation is executed asynchronously and in parallel with the CPU-side bucket hash operation, and the data transfer latency is essentially hidden within the bucket calculation latency.

[0087] The path-aware dual-stream parallel execution subunit is deployed across heterogeneous CPU and GPU hardware, splitting objects within a batch into two independent hardware execution streams for parallel scheduling based on path identifiers: incremental path batches (path one / path two objects) are submitted to the CPU-side SIMD execution stream for reuse. Vectorized linear extrapolation is performed, and the SIMD instruction utilization is close to the theoretical peak. The full path batch (path three objects) is moved to GPU memory via DMA and then submitted to the GPU-side CUDAStream execution stream to execute the vectorized Newton iteration kernel function. The two types of execution streams run synchronously and in parallel on the CPU and GPU respectively, without blocking each other.

[0088] The five functional modules of the device described in Embodiment 4 correspond one-to-one with steps S101 to S105 in Embodiment 1, forming a complete device protection system. The deployment form can be a single machine with multiple cards or a distributed cluster. The protection scope of this application is not limited by the specific deployment form.

[0089] Figure 2 This is a schematic diagram of the main components of the streaming real-time solution system for nonlinear equations based on sensitivity buffering and vectorized bucketing in an embodiment of the present invention. Figure 2As shown, the nonlinear equation system 1 based on sensitivity caching and vectorized bucketing provided in this embodiment of the invention includes a preprocessing module 10, a channel-based flow determination module 20, an iterative solution module 30, an adaptive feedback module 40, and a hardware parallel scheduling module 50.

[0090] The preprocessing module 10 is used to collect the original input data of each target object in the current batch, normalize the original input data to obtain the current input vector of each target object, retrieve the historical input vector of each target object in the previous period, and obtain the change vector of the current input vector relative to the historical input vector through vector difference operation. The channel-based flow determination module 20 is used to divide each target object into a corresponding solution channel based on a preset sparse micro-variation threshold and an adaptive threshold. The solution channel includes a sparse sensitivity test-free path, an incremental extrapolation verification path, and a full solution path, and outputs the corresponding implicit parameter estimate or iterative initial guess value. The iterative solution module 30 is used to perform a finite number of Newton correction iterations on target objects that fail the verification of the split-to-full-solution path and the incremental extrapolation verification path, starting with a pre-built approximate function table or the initial guess value of the iteration. After the iteration converges, the sensitivity matrix is ​​pre-calculated and the caching is completed. The adaptive feedback module 40 is used to summarize the solution results and solution residuals of each target object in the current batch, and to calculate the average posterior error of all target objects under the incremental path based on the solution results and solution residuals. Based on the average posterior error, the adaptive threshold is automatically adjusted, and the historical state quadruplets are updated in a differentiated manner according to the solution channel to which the target object belongs, thus building a cross-period adaptive feedback link. The hardware parallel scheduling module 50 is used to perform parameter similarity-aware hash bucketing, state quadruple-guided memory layout transformation, and path-aware vectorized dual-stream parallel scheduling on each target object in the current batch, efficiently mapping the full solution task to the hardware execution unit.

[0091] Figure 7 This is a schematic diagram of the physical structure of an electronic device provided in an embodiment of the present invention, such as... Figure 7 As shown, the electronic device 60 includes: a processor 601, a memory 602, and a bus 603; The processor 601 and the memory 602 communicate with each other via the bus 603. The processor 601 is used to call program instructions in the memory 602 to execute the methods provided in the above-described method embodiments, and to execute the methods provided in the embodiments of the present invention.

[0092] This embodiment provides a non-transitory computer-readable storage medium that stores computer instructions, which cause a computer to execute the method provided in this embodiment of the invention.

[0093] Those skilled in the art will understand that all or part of the steps of the above method embodiments can be implemented by hardware related to program instructions. The aforementioned program can be stored in a computer-readable storage medium. When the program is executed, it performs the steps of the above method embodiments. The aforementioned storage medium includes various storage media capable of storing program code, such as ROM, RAM, magnetic disk, or optical disk.

[0094] The specific embodiments described above do not constitute a limitation on the scope of protection of this invention. Those skilled in the art should understand that various modifications, combinations, sub-combinations, and substitutions can occur depending on design requirements and other factors. Any modifications, equivalent substitutions, and improvements made within the spirit and principles of this invention should be included within the scope of protection of this invention.

Claims

1. A real-time streaming solution method for nonlinear equation systems based on sensitivity buffering and vectorized bucketing, characterized in that, include: Collect the original input data of each target object in the current batch, normalize the original input data to obtain the current input vector of each target object, retrieve the historical input vector of each target object in the previous period, and obtain the change vector of the current input vector relative to the historical input vector through vector difference operation; Based on a preset sparse infinitesimal threshold and an adaptive threshold, each target object is assigned to a corresponding solution channel. The solution channel includes a sparse sensitivity verification path, an incremental extrapolation verification path, and a full solution path, and outputs the corresponding implicit parameter estimates or iterative initial guesses. For target objects that fail the verification of the full solution path and the incremental extrapolation verification path, a finite number of Newton correction iterations are performed starting from the pre-constructed approximate function table or the initial guess value of the iteration. After the iteration converges, the sensitivity matrix is ​​pre-calculated and the caching is completed. Summarize the solution results and solution residuals for each target object in the current batch, calculate the average posterior error of all target objects under the incremental path based on the solution results and solution residuals, automatically adjust the adaptive threshold based on the average posterior error, update the historical state quadruples according to the solution channel to which the target object belongs, and build a cross-cycle adaptive feedback link. For each target object in the current batch, parameter similarity-aware hash bucketing, state quadruple-guided memory layout transformation, and path-aware vectorized dual-stream parallel scheduling are performed to efficiently map the full solution task to the hardware execution unit.

2. The real-time streaming solution method for nonlinear equation systems based on sensitivity buffering and vectorized bucketing according to claim 1, characterized in that, The step of obtaining the change vector of the current input vector relative to the historical input vector through vector interpolation includes: The change vector is calculated using formula (1); Official (1); In the formula, For the changing vector, This is the current input vector. Let t be the historical input vector, i be the i-th target object, t be the current calculation cycle, and t-1 be the previous historical calculation cycle.

3. The real-time streaming solution method for nonlinear equation systems based on sensitivity buffering and vectorized bucketing according to claim 2, characterized in that, The process of assigning each target object to a corresponding solution channel based on a preset sparse infinitesimal threshold and an adaptive threshold includes: When the changing vector Satisfy sparsity constraints And satisfy the amplitude constraint Each target object is assigned to a sparse, sensitivity-based, test-free path. Computing devices identify input change vectors Non-zero-dimensional sets, based solely on cache sensitivity matrix Read from Columns, perform sparse weighted vector addition: The implicit parameter estimate is calculated using formula (2); Official (2); In the formula, These are the estimated values ​​of the hidden parameters. This represents the estimated value of the latent parameters of the i-th cell in the previous period. For the changing vector, Let be the first-order partial derivative of the j-th dimension input variable with respect to the latent parameter. When the target object is assigned to the sparse sensitivity-free path, the output is the estimated value of the latent parameter.

4. The real-time streaming solution method for nonlinear equation systems based on sensitivity buffering and vectorized bucketing according to claim 3, characterized in that, The process of dividing each target object into corresponding solution channels based on a preset sparse infinitesimal threshold and an adaptive threshold includes: When the changing vector The norm satisfies If the triggering conditions for the sparse sensitivity exemption path are not met, each target object will be assigned to the incremental extrapolation verification path. Computing devices utilize cache sensitivity matrix Perform full matrix-vector multiplication: The initial guess value for iteration is calculated using formula (3); Official (3); In the formula, The initial guess value for iteration is output when the target object is assigned to the incremental extrapolation verification path.

5. The real-time streaming solution method for nonlinear equation systems based on sensitivity buffering and vectorized bucketing according to claim 4, characterized in that, The process of dividing each target object into corresponding solution channels based on a preset sparse infinitesimal threshold and an adaptive threshold includes: when or target object When there is no valid historical state, each target object is assigned to the full solution path.

6. The real-time streaming solution method for nonlinear equation systems based on sensitivity buffering and vectorized bucketing according to claim 1, characterized in that, The process of performing a finite number of Newton correction iterations, starting with a pre-constructed approximate function table or an initial guess for iteration, includes: Based on the initial guess value Starting from this point, the computing device executes at most... Step Newton correction iteration: The new implicit parameters are calculated using formula (4); Official (4); In the formula, These are the newly obtained implicit parameters after a round of Newtonian corrections. This is the current estimate of the hidden parameters. Let f be the first-order partial derivative of the function f with respect to the parameter p. Output the target value; After each step, the current residual is calculated. If the residual meets the accuracy tolerance, the iteration is terminated early, without having to execute to the upper limit. This step is taken to avoid unnecessary computational overhead; Iterative convergence to Then, the computing device uses the Jacobian inverse matrix already computed in the final iteration step. and numerical differentiation Calculate and cache the sensitivity matrix: The sensitivity matrix is ​​calculated using formula (5); Official (5); In the formula, For the sensitivity matrix, It is the Jacobian inverse matrix. It is a numerical differential.

7. The real-time streaming solution method for nonlinear equation systems based on sensitivity buffering and vectorized bucketing according to claim 1, characterized in that, The automatic adjustment of the adaptive threshold based on the average posterior error includes: The computing device will average the residuals With preset upper bound and preset lower bound Compare and perform adaptive threshold updates: like Then the current adaptive threshold The estimate is too conservative, the incremental effective domain is underestimated, and the computing device needs to be expanded. This allows more target objects to undergo incremental extrapolation verification in the next cycle; like This indicates that the error accumulation exceeds the acceptable range, the incremental effective domain estimate is too large, and the computing device is underutilized. Meanwhile, objects with excessive residuals in this period are marked as mandatory full solutions for the next period to ensure that the solution accuracy does not gradually deteriorate due to continuous incremental paths; like The threshold remains unchanged.

8. A real-time streaming solution system for nonlinear equations based on sensitivity buffering and vectorized bucketing, characterized in that, include: The preprocessing module is used to collect the original input data of each target object in the current batch, normalize the original input data to obtain the current input vector of each target object, retrieve the historical input vector of each target object in the previous period, and obtain the change vector of the current input vector relative to the historical input vector through vector difference operation. The channel-based flow determination module is used to divide each target object into a corresponding solution channel based on a preset sparse infinitesimal threshold and an adaptive threshold. The solution channel includes a sparse sensitivity-free path, an incremental extrapolation verification path, and a full solution path, and outputs the corresponding implicit parameter estimates or iterative initial guesses. The iterative solution module is used to perform a finite number of Newton correction iterations on target objects that fail the verification of the split-to-full-solution path and the incremental extrapolation verification path, starting with a pre-built approximate function table or the initial guess value of the iteration. After the iteration converges, the sensitivity matrix is ​​pre-calculated and cached. The adaptive feedback module is used to summarize the solution results and solution residuals of each target object in the current batch, and to calculate the average posterior error of all target objects under the incremental path based on the solution results and solution residuals. Based on the average posterior error, the adaptive threshold is automatically adjusted, and the historical state quadruples are updated in a differentiated manner according to the solution channel to which the target object belongs, thus building a cross-period adaptive feedback link. The hardware parallel scheduling module is used to perform parameter similarity-aware hash bucketing, state quadruple-guided memory layout transformation, and path-aware vectorized dual-stream parallel scheduling on each target object in the current batch, efficiently mapping the full solution task to the hardware execution unit.

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

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

Images