Learning of LPV Models With Linear Fractional Representations: Initialization, Optimization, and Conditioning
Listen
Radio episode about this paper
Transcript
Introduction to the show: ident: Robotics Radio. Generated commentary on the latest robotics and control papers.
Rosa: We're looking at the paper: "Learning of LPV Models With Linear Fractional Representations".
Dev: Here's the gist of the paper. Linear Parameter-Varying (LPV) models with Linear Fractional Representation (LFR) can describe a wide class of nonlinear systems with a control-friendly structure.
Rosa: The work proposes an initialization strategy based on the Best Linear Approximator (BLA), and compares two multiple shooting methods, Unconstrained Multiple Shooting (UMS) and Encoder-Based Multiple Shooting (EBMS), to improve the conditioning of non-convex optimization problems.
Dev: Model Structure and Representation The paper considers nonlinear discrete-time data-generating systems described by a state-space representation.
Rosa: LPV models with Linear Fractional Representations are considered, following well-posed parameterizations proposed in Drenth et al.
Title and authors: Rosa: So we're looking at this paper titled "Learning of LPV Models With Linear Fractional Representations: Initialization, Optimization, and Conditioning." It’s about these LPV models with Linear Fractional Representations.
Dev: Right. Essentially, they are dealing with nonlinear systems that have a specific structure that makes them kind of friendly for control applications. The core problem they tackle is that identifying these models along with their scheduling map from input to output creates this really tough non-convex optimization problem, and it’s super sensitive to how you start the process.
Taro: So, the paper is focusing on solving that initialization sensitivity issue by proposing a specific strategy based on something called the Best Linear Approximator or BLA. I wonder if starting from a good guess really makes all the difference in these kinds of identification tasks?
Rosa: Exactly. The authors suggest this BLA approach as an initialization strategy because they found it’s effective for various nonlinear model structures, and they show that it helps reduce the variance in accuracy when compared to just picking random starting points.
Dev: But they don't stop there. They look at how rational dependency in these LPV-LFR models messes with the conditioning of that cost function during optimization, and then they propose two specific multiple shooting methods designed to make that problem easier to solve.
Taro: Two methods? Unconstrained Multiple Shooting, or UMS, and Encoder-Based Multiple Shooting, or EBMS. I’m curious how those two different approaches actually compare when dealing with the difficulty of rational dependency.
Rosa: Well, it seems they suggest a trade-off there too. UMS is simpler to tune and works well if you only have a few data records, but EBMS can use many short records to improve the conditioning further, even though that means training an extra encoder and tuning more parameters.
Dev: That’s where I see the engineering challenge. We need stability in real-time loops, so we look at how these methods handle those sub-records—the small chunks of data they use for optimization. The paper shows both UMS and EBMS can reduce the spread when you start with random initializations, which is a good sign for robustness.
Taro: But the numerical study on their mass-spring-damper example showed that BLA initialization consistently gave accurate results, whereas random initialization had a huge spread, but then they also found that both UMS and EBMS helped reduce that spread for randomly initialized models too. That suggests the shooting method helps generally.
Rosa: But the real win seems to be when you look at the rational dependency aspect specifically. The analysis points out that BLA initialization starts optimization in a part of the loss landscape that is better conditioned, which helps subsequent refinement, even if it doesn't fully solve the conditioning issue on its own.
Dev: So, for someone building a system like this, what does this mean practically? It means you don't have to just throw random parameters at the wall and hope for the best; you can use a smart starting point from BLA.
Taro: And when it comes to those multiple shooting methods, specifically when dealing with rational LPV-LFR models, EBMS actually performs better than UMS in reducing that spread for almost every time step. That's a pretty strong result for the more complex case you mentioned earlier.
Rosa: So the implication is that if you have many short sub-records and need to improve the conditioning of your cost function, using EBMS seems like it gives you better results without sacrificing performance, unlike UMS which is simpler but less effective in those specific tough scenarios.
Dev: It points toward a recommendation: for a small number of sub-records, UMS is the way to go because it’s computationally efficient and easy to tune. But if you are dealing with rational LPVLFR models where you need that extra conditioning boost from shorter records, EBMS is the method that doesn't give up on performance.
Taro: That complexity trade-off between the two methods is something we should definitely keep watching as we design more autonomous systems that need to learn these complex dynamics.
Rosa: Exactly. So, to wrap up this discussion on "Learning of LPV Models With Linear Fractional Representations: Initialization, Optimization, and Conditioning," the main thing is that BLA initialization provides a solid foundation, and for tough cases with rational dependency, EBMS seems like the better tool to ensure you get good results.
Dev: I agree. We're looking at how they tackle the initialization problem and then how they use multiple shooting techniques to manage those ill-conditioned cost functions caused by rational dependency in LPV-LFR models.
Taro: It’s interesting seeing how a specific initialization method can lead to different performance characteristics depending on the complexity of the model structure, especially when you add the complication of rational dependency.
Rosa: So that’s our take on this work today. We’ve seen how they proposed BLA initialization and compared UMS and EBMS for conditioning these non-convex problems in LPV models with Linear Fractional Representations.
Dev: That’s all we have for this one. Next up, we'll be looking at some of the other papers on arXiv that are shaping the current landscape in robotics and control systems.
The paper's summary: Rosa: So, we just talked about how these LPV models work and how hard they are to optimize when you use rational dependency in them.
Dev: Right, and that’s where this paper comes in—it looks at how to fix the start of the optimization process with a specific method called BLA initialization.
Rosa: Basically, they show that if you start your optimization from a good guess based on an approximation called a Best Linear Approximator, you get much better results than just picking random starting numbers.
Dev: It’s about making sure the initial model guess is in a spot where the optimization cost function isn't too bumpy, which makes the whole process more stable.
Rosa: But it doesn't just stop there with initialization; they look at how to handle those tough non-convex problems during the actual training phase.
Dev: They compare two different ways of running multiple shooting, which are Unconstrained Multiple Shooting and Encoder-Based Multiple Shooting.
Rosa: It turns out both methods help reduce the spread of the results you get from a model that started randomly, but they do it in different ways.
Dev: Unconstrained Multiple Shooting is straightforward and good for just a few data records, but Encoder-Based Multiple Shooting can use many short data chunks to give you even better conditioning.
Rosa: That means if you’re dealing with those rational LPV models, EBMS seems to perform much better at reducing the spread compared to UMS.
Dev: So the paper suggests a two-pronged approach: use BLA initialization for a solid start, and then pick your multiple shooting method based on whether you need simplicity or maximum conditioning improvement.
Rosa: That makes sense because if you’re building something real-time, you want to know which method keeps things stable when the world misbehaves.
Dev: Exactly. And the implication is that for complex systems with rational dependencies, using EBMS gives you a better chance of getting accurate predictions without sacrificing performance.
Rosa: So if you’re designing a system that needs to learn these kinds of complex dynamics, this paper gives you specific tools to tackle the tough parts—the starting point and the optimization method.
Dev: It's definitely worth looking at how they handle that trade-off between simplicity and performance in those simulation loops.
The paper's improvements: Taro: So, we’ve talked about how BLA initialization helps get us started in the right spot for optimization, and now we’re looking at what else they suggest to make this whole process smoother.
Rosa: The paper points out that because these LPV models have a rational dependency, the way the cost function behaves gets really weird and hard to manage during training.
Dev: Right, so they aren't just relying on a good start; they’re suggesting ways to fix how the optimization loop itself handles that bad conditioning.
Rosa: They show that using multiple shooting methods is key here, and they compare Unconstrained Multiple Shooting against Encoder-Based Multiple Shooting again.
Dev: They emphasize that EBMS can really help stabilize the whole learning process when you’re dealing with those rational LPV-LFR models because it uses more data records to improve the fit.
Taro: That means for autonomy, if you have a lot of short data chunks available, EBMS seems like it offers a better way to ensure the system doesn't just get stuck in a poor solution space.
Rosa: The paper also suggests that they need to be careful about what they measure when it comes to the rational dependency itself.
Dev: They argue that if you’re modeling an affine case, you should actually set a specific parameter, Dzw, to zero and scale things down in a specific way.
Rosa: That's like saying for simple cases, you can simplify the math by setting some terms to zero and normalizing the scaling factor.
Taro: So it’s about finding those shortcuts so that the optimization doesn't have to deal with all that messy rational dependency every single time it runs.
Dev: Exactly. The implication is that for real-time systems, you want methods like EBMS if your data allows for more than just a few records, because they give you better control over the error accumulation.
Rosa: It suggests that the choice of initialization and the choice of shooting method are both very important factors in achieving low error rates, especially when dealing with these complex LPV structures.
Taro: It makes me wonder how much more robust these methods become when we try to apply them to even more dynamic physical systems outside of just mass-spring-damper examples.
Conclusion: Rosa: So we’re wrapping up our look at "Learning of LPV Models With Linear Fractional Representations: Initialization, Optimization, and Conditioning." Basically, the paper shows that by using a smart starting point with BLA initialization and choosing the right multiple shooting method like EBMS for tough problems, you can get much more stable and accurate results.
Dev: It’s about making sure we aren't wasting computational time on optimization paths that are just going to fail because the cost function is too bumpy.
Taro: I agree, especially when we look at real-world failure modes; a bad initialization could lead a learning agent completely off course in a way that’s hard to recover from.
Rosa: The main implication for us is that we don't have to rely on purely random setups anymore; having that BLA initialization strategy seems like it’s the standard way to go now for these kinds of models.
Dev: For someone running real-time loops, this means we can trust the optimization process more because we know the starting point is well-behaved, even when the data structure is complicated with rational dependencies.
Taro: It changes how I think about designing those learning agents; if you can guarantee a good start and use a robust shooting method like EBMS for complex dynamics, you build something that’s way more resilient to unexpected world behavior.
Rosa: So we’ve seen how initialization and optimization choices matter for these LPV models, but it leaves open questions about how these methods scale up when the system gets even more complex than this example.
Dev: Right, and the authors themselves pointed out that they didn't fully map out the complexity trade-off between UMS and EBMS across every possible scenario.
Taro: That is a fair limitation; knowing exactly where one method wins over another in every single setup is hard to prove without a massive amount of testing.
Rosa: So, for now, we have this analysis on initialization and optimization methods for LPV models with Linear Fractional Representations as our main piece here.
Dev: That’s all the time we have for this one on arXiv today. Next up, we'll be looking at some papers that talk about how robots are learning to navigate the world without needing explicit maps.
University of Technology Eindhoven · HUN-REN Institute for Computer Science and Control
eess.SY, cs.SY
Submitted: 2026-11-10
Updated: 2026-11-10
Comments: Preprint submitted to the IFAC Journal of Systems and Control
License: http://creativecommons.org/licenses/by-nc-sa/4.0/
Importance score: 66/100
The gist: Linear Parameter-Varying (LPV) models with Linear Fractional Representation (LFR) can describe a wide class of nonlinear systems with a control-friendly structure.
Key concepts
- LPV Models with LFR
- These are nonlinear systems described using Linear Parameter-Varying models represented by a Linear Fractional Representation. This structure allows the model to capture complex nonlinear dynamics while maintaining a control-friendly structure, making it suitable for various engineering applications.
- Best Linear Approximator (BLA) Initialization
- This strategy involves finding an initial Linear Time-Invariant (LTI) state-space model that minimizes simulation error. This estimate is then used to initialize the LPV-LFR model, ensuring a more stable and well-conditioned starting point for the subsequent complex optimization process.
- Multiple Shooting Methods (UMS vs. EBMS)
- These are numerical techniques used in optimization to solve problems by breaking them into smaller segments (sub-records). Unconstrained Multiple Shooting (UMS) is simple, while Encoder-Based Multiple Shooting (EBMS) uses an encoder to exploit many short sub-records, often providing better conditioning for complex rational LPVLFR models.
Terminology
Summary
Linear Parameter-Varying (LPV) models with Linear Fractional Representation (LFR) can describe a wide class of nonlinear systems with a control-friendly structure. p. 0 schoukens, r. ∗∗ Systems and Control Laboratory, HUN-REN Institute for Computer
Science and Control, Budapest, Hungary
Abstract: Linear Parameter-Varying (LPV) models with Linear Fractional Representation
(LFR) can describe a wide class of nonlinear systems with a control-friendly structure. Instead, our work
proposes an initialization strategy based on the Best Linear Approximator (BLA). Furthermore,
motivated by an analysis of the impact of rational-dependency LPV-LFR models on the conditioning of the non-convex cost, two multiple shooting methods that improve the conditioning,
unconstrained multiple shooting (UMS) and encoder-based multiple shooting (EBMS), are
compared.Where the paper says it
Where the paper says it
Model Structure and Representation
The paper considers nonlinear discrete-time data-generating systems described by a state-space representation. LPV models with Linear Fractional Representations are considered, following well-posed parameterizations proposed in Drenth et al. p. 2 2 LPV models with Linear Fractional Representation
In this work we consider the class of LPV models with Linear Fractional Representations. Models follow well-posedby-construction parameterizations as proposed in Drenth
et al. , pˆk,np
Irnp
). (3)
wˆk and ˆzk represent the latent variables of the LFR,
eliminating these variables results in the equivalent statespace representation with scheduling dependent matrices:
Gθ :
f(xk, uk, pk) = A(pk)xk + B(pk)uk,
g(xk, uk, pk) = C(pk)xk + D(pk)uk,
(4)
where A(pk), B(pk), C(pk) and D(pk) represent schedulingdependent matrix functions. , pˆk,np
Irnp
). (3)
wˆk and ˆzk represent the latent variables of the LFR,
eliminating these variables results in the equivalent statespace representation with scheduling dependent matrices:
Gθ :
f(xk, uk, pk) = A(pk)xk + B(pk)uk,
g(xk, uk, pk) = C(pk)xk + D(pk)uk,
(4)
where A(pk), B(pk), C(pk) and D(pk) represent schedulingdependent matrix functions. , a
ResNet, architecture is used for estimating the scheduling
map ψˆ
θ. The trainable parameters of the LPV-LFR model are
collected in θG for the affine and rational cases:
θ
aff
G = vec (Ax, Bw, Bu, Cz, Dzu, Cy, Dyw), (5)
θ
rat
G = vec θ
aff
G , DA, DB, Dd
.Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Initialization Strategy
The authors propose an initialization strategy based on the Best Linear Approximator (BLA). This involves obtaining a parametric BLA estimate by directly identifying an LTI state-space model which minimizes the mean-squared simulation error cost. p. 3 First, a parametric BLA
estimate with state-space representation must be obtained. In this work this is obtained by directly identifying an
LTI state-space model which minimizes the mean-squared
simulation error cost:
V (θ) = 1
N
N
X−1
k=0
∥yk − yˆk∥
2
2
, (10)
where N is the simulation length and ˆyk represents the
simulation output. This
transformation ensures the states of the transformed BLA
model have unit variance, which is considered favorable as
initial guess, as the state is an input of the NN scheduling
map (Dehkordi et al. Secondly, based on the transformed system matrices of the
BLA estimate, an LPV-LFR model is initialized using the
following initialization strategy:
Ax = A˜BLA, Bw = 0,
Bu = B˜BLA, Cz ∼ U(−0. This
transformation ensures the states of the transformed BLA
model have unit variance, which is considered favorable as
initial guess, as the state is an input of the NN scheduling
map (Dehkordi et al. Secondly, based on the transformed system matrices of the
BLA estimate, an LPV-LFR model is initialized using the
following initialization strategy:
Ax = A˜BLA, Bw = 0,
Bu = B˜BLA, Cz ∼ U(−0. 1),
Dzu ∼ U(−0. 1), Cy = C˜BLA,
Dyw = 0, Dyu = D˜BLA.Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Multiple Shooting Methods Comparison
Two unconstrained multiple shooting methods are compared: Unconstrained Multiple Shooting (UMS) and Encoder-Based Multiple Shooting (EBMS). UMS is simple to tune and well-suited to few sub-records, whereas EBMS can exploit many short sub-records to further improve conditioning, at the cost of training an encoder and tuning additional hyperparameters. p. 0 The results also show that both UMS and
EBMS reduce the spread for randomly initialized models. UMS is simple to tune and well
suited to few sub-records, whereas EBMS can exploit many short sub-records to further improve
conditioning, at the cost of training an encoder and tuning additional hyperparameters. The initialization and multiple shooting methods are evaluated on a nonlinear massspring-damper example, showing that BLA initialization consistently yields accurate results,
whereas random initialization has a large spread. The results also show that both UMS and
EBMS reduce the spread for randomly initialized models.Where the paper says it
Where the paper says it
Numerical Study Findings
The numerical experiments on a nonlinear mass-spring-damper example show that BLA initialization consistently yields accurate results, whereas random initialization has a large spread. The results also show that both UMS and EBMS reduce the spread for randomly initialized models. p. 0 The initialization and multiple shooting methods are evaluated on a nonlinear massspring-damper example, showing that BLA initialization consistently yields accurate results,
whereas random initialization has a large spread. The results also show that both UMS and
EBMS reduce the spread for randomly initialized models. Both MS
methods show reduced spread as the number of records
increases, attributable to the improved conditioning of
the cost for shorter sub-records, but the spread of EBMS
methods keeps decreasing, as the median and IQR of the
UMS method worsens. We conjecture that, in the case with
the largest number of sub-records of EBMS, two effects
occur: (i) the shorter sub-records improve conditioning
of the cost function; (ii) the large amount of overlap
increases the variance of the estimates in the UMS case,
but decreases the variance of the estimates in the EBMS
case, as the number of records scales with the overlap,
improving the training of the encoder.Where the paper says it
Where the paper says it
Conclusion and Recommendations
The work contributes an analysis showing how rational-dependency degrades conditioning of the simulation cost, BLA initializations for LPV models with Linear Fractional Representation and well-posed rational parameterization, and a numerical comparison of UMS and EBMS. The results lead to recommendations that in general UMS provides a simple to tune, computationally efficient method for a relatively small number of sub-records. p. 6 Although only one simulation example is considered in this
work, by analyzing two model structures with different
conditioning of the cost function, important insights can
still be gained. In particular we note that in general
UMS provides a simple to tune, computationally efficient
method for a relatively small number of sub-records. Although only one simulation example is considered in this
work, by analyzing two model structures with different
conditioning of the cost function, important insights can
still be gained. In particular we note that in general
UMS provides a simple to tune, computationally efficient
method for a relatively small number of sub-records. In particular we note that in general
UMS provides a simple to tune, computationally efficient
method for a relatively small number of sub-records. In
cases where short sub-record are required to improve conditioning of the cost function, such as for rational LPVLFR models, EBMS methods provide a solution that does
not sacrifice achievable performance or spread, but comes
at the cost of more user burden and additional complexity. In particular we note that in general
UMS provides a simple to tune, computationally efficient
method for a relatively small number of sub-records. In
cases where short sub-record are required to improve conditioning of the cost function, such as for rational LPVLFR models, EBMS methods provide a solution that does
not sacrifice achievable performance or spread, but comes
at the cost of more user burden and additional complexity. (3) A numerical comparison of UMS and EBMS, highlighting their complexity trade-off. The remainder of this paper is structured as follows: first,
in Section 2 the problem setting and LPV-LFR model
structure are introduced. (3) A numerical comparison of UMS and EBMS, highlighting their complexity trade-off. The remainder of this paper is structured as follows: first,
in Section 2 the problem setting and LPV-LFR model
structure are introduced. (3) A numerical comparison of UMS and EBMS, highlighting their complexity trade-off. The remainder of this paper is structured as follows: first,
in Section 2 the problem setting and LPV-LFR model
structure are introduced.Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Pruning redundant reasoning tokens
The results show that both model types and initialization methods are capable of reaching a low NRMSE (≤ 0.02). The initialization strategy has the largest influence on achieved results and reduces the spread of results in the rational case. p. 5 First, Figure 1 shows the following: (i) both model types
and initialization methods are capable of reaching a low
NRMSE ( ≤ 0. 02); (ii) the initialization strategy has
the largest influence on achieved results and reduces the
spread of results in the rational case. 02); (ii) the initialization strategy has
the largest influence on achieved results and reduces the
spread of results in the rational case. Possibly, the BLA
initialization starts optimization in a well-conditioned part
of the loss landscape, improving subsequent refinement;
(iii) no clear differentiation between the spread of results
of rational and affine models is observed in the BLA initialization case; (iv) randomly initialized rational models
benefit in a reduced spread of results as multiple shooting
is used. 02); (ii) the initialization strategy has
the largest influence on achieved results and reduces the
spread of results in the rational case. Possibly, the BLA
initialization starts optimization in a well-conditioned part
of the loss landscape, improving subsequent refinement;
(iii) no clear differentiation between the spread of results
of rational and affine models is observed in the BLA initialization case; (iv) randomly initialized rational models
benefit in a reduced spread of results as multiple shooting
is used. Possibly, the BLA
initialization starts optimization in a well-conditioned part
of the loss landscape, improving subsequent refinement;
(iii) no clear differentiation between the spread of results
of rational and affine models is observed in the BLA initialization case; (iv) randomly initialized rational models
benefit in a reduced spread of results as multiple shooting
is used. In particular, EBMS strongly reduces the spread,
outperforming UMS for nearly each T; (v) sub-record
lengths of 5 and 20 are too short to accurately capture
the dynamics of the data-generating system. Possibly, the BLA
initialization starts optimization in a well-conditioned part
of the loss landscape, improving subsequent refinement;
(iii) no clear differentiation between the spread of results
of rational and affine models is observed in the BLA initialization case; (iv) randomly initialized rational models
benefit in a reduced spread of results as multiple shooting
is used. In particular, EBMS strongly reduces the spread,
outperforming UMS for nearly each T; (v) sub-record
lengths of 5 and 20 are too short to accurately capture
the dynamics of the data-generating system.Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
How the training signal is built
The optimization of the cost follows a two-step approach proposed in Bemporad (2025). A 1000 iterations of Adam provide a warm start for the limited-memory Broyden-Fletcher-Goldfarb-Shanno (L-BFGS) algorithm of at most 10 000 iterations. p. 4 Optimization of this cost follows the two-step approach proposed in Bemporad (2025). A 1000 iterations
of Adam provide a warm start for the limited-memory
Broyden-Fletcher-Goldfarb-Shanno (L-BFGS) algorithm
of at most 10 000 iterations. Furthermore, early-stopping
is used as regularization. In this method, the model with
the lowest simulation error on the validation data is selected during training, preventing overfitting on the training data.Where the paper says it
Where the paper says it
Where the gains come from
The analysis of rational dependency degrades conditioning of the simulation cost. The well-posed parameterization using the matrix exponential cannot represent Dzw = 0. p. 3 (13)
Ideally, initializing Dzw = 0 would be chosen, as this
would correspond to affine-dependency and would reduce
γ in (9) to one for the initialized model. However, the
well-posed parameterization using the matrix exponential
cannot represent Dzw = 0. ✷
In the affine-dependency case, γ = 1 and LDzw = 0. The
additional scaling of Lf through γ in (9) clearly increases
the bound of Lv according to (7) for models with rational
dependency and small ϵ. The
additional scaling of Lf through γ in (9) clearly increases
the bound of Lv according to (7) for models with rational
dependency and small ϵ. This stresses the need for methods
that improve the conditioning of the cost function, such as
multiple shooting. 02); (ii) the initialization strategy has
the largest influence on achieved results and reduces the
spread of results in the rational case. Possibly, the BLA
initialization starts optimization in a well-conditioned part
of the loss landscape, improving subsequent refinement;
(iii) no clear differentiation between the spread of results
of rational and affine models is observed in the BLA initialization case; (iv) randomly initialized rational models
benefit in a reduced spread of results as multiple shooting
is used.Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
The results show that BLA initialized models follow the pattern of the affine case. However, the randomly initialized models show a more interesting trend. p. 5 Similar trends are shown in the rational case in Figure
3, the behaviour of the BLA initialized methods follows
the pattern of the affine case. However, the randomly
initialized models show a more interesting trend. However, the randomly
initialized models show a more interesting trend. Both MS
methods show reduced spread as the number of records
increases, attributable to the improved conditioning of
the cost for shorter sub-records, but the spread of EBMS
methods keeps decreasing, as the median and IQR of the
UMS method worsens. However, the randomly
initialized models show a more interesting trend. Both MS
methods show reduced spread as the number of records
increases, attributable to the improved conditioning of
the cost for shorter sub-records, but the spread of EBMS
methods keeps decreasing, as the median and IQR of the
UMS method worsens.Where the paper says it
Where the paper says it
Where the paper says it
The actual NRMSE of the predictions in figures 2 and 3 does not show this same trend indicating that for lower number of sub-records, the encoder network is able to learn initial state estimates of the training set or that estimating initial states accurately has little importance for long sub-records on the considered example. p. 5 The state NRMSE
and its IQR decrease as the number of records increases,
matching expected behaviour. Interestingly, the actual
NRMSE of the predictions in figures 2 and 3 does not
show this same trend indicating that for lower number
of sub-records, the encoder network is able to learn initial
state estimates of the training set or that estimating initial
states accurately has little importance for long sub-records
on the considered example. We make two
observations: (i) despite the theoretical increase in dataefficiency, increasing the overlap has no meaningful impact
on convergence rate; (ii) when using a BLA initialization,
MS almost always has negative effect, or no positive
impact, on the convergence rate of the considered example. However, it must be noted that this is convergence rate
in terms of iterations, in terms of wall-clock time, MS
provides theoretical benefit over single-shooting, given
parallel compute can be leveraged. We make two
observations: (i) despite the theoretical increase in dataefficiency, increasing the overlap has no meaningful impact
on convergence rate; (ii) when using a BLA initialization,
MS almost always has negative effect, or no positive
impact, on the convergence rate of the considered example. However, it must be noted that this is convergence rate
in terms of iterations, in terms of wall-clock time, MS
provides theoretical benefit over single-shooting, given
parallel compute can be leveraged. merical study, both showing improvements in learning of
randomly initialized models. Furthermore, the complexity
trade-off between these two methods has been illustrated,
leading to recommendations for the user. merical study, both showing improvements in learning of
randomly initialized models. Furthermore, the complexity
trade-off between these two methods has been illustrated,
leading to recommendations for the user.Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
The results show median and IQR of BLA initialized models and randomly initialized models. The state NRMSE and its IQR decrease as the number of records increases, matching expected behaviour. p. 5 BLA initialized and randomly initialized models follow the same trend. The state NRMSE
and its IQR decrease as the number of records increases,
matching expected behaviour.Where the paper says it
The work contributes an analysis showing how rational-dependency degrades conditioning of the simulation cost, BLA initializations for LPV models with Linear Fractional Representation and well-posed rational parameterization, and a numerical comparison of UMS and EBMS. The results lead to recommendations that in general UMS provides a simple to tune, computationally efficient method for a relatively small number of sub-records. In cases where short sub-record are required to improve conditioning of the cost function, such as for rational LPVLFR models, EBMS methods provide a solution that does not sacrifice achievable performance or spread. The paper concludes by illustrating the complexity trade-off between these two methods.
The work has analyzed the conditioning of cost landscapes of LPV-LFR models. A BLA initialization method which reduces the impact of the conditioning has been proposed and analyzed through numerical experiments, showing major improvement over random initialization in the considered example. p. 6 CONCLUSION
This work has analyzed the conditioning of cost landscapes of LPV-LFR models. A BLA initialization method
which reduces the impact of the conditioning has been
proposed and analyzed through numerical experiments,
showing major improvement over random initialization in
the considered example.Where the paper says it
The paper is 2611.14668. The single most informative sentence about the paper's subject and finding is: Linear Parameter-Varying (LPV) models with Linear Fractional Representation (LFR) can describe a wide class of nonlinear systems with a control-friendly structure.
Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.
Improvements for AI systems
-
BLA Initialization for LPV-LFR models ensures that
the LPV-LFR model matches the behaviour of the BLA estimate at the first iteration,
which leads to a more stable initial guess for subsequent optimization steps. -
The use of multiple shooting methods, specifically Unconstrained Multiple Shooting (UMS) and Encoder-Based Multiple Shooting (EBMS), reduces the spread of results, as
EBMS strongly reduces the spread, outperforming UMS for nearly each T
when using rational LPVLFR models. -
For affine dependency models, initializing Dzw = 0 would be chosen to correspond to affine dependency and
reduce gamma in (9) to one for the initialized model.
Abstract
Linear Parameter-Varying (LPV) models with Linear Fractional Representation (LFR) can describe a wide class of nonlinear systems with a control-friendly structure. However, identifying these models together with their scheduling map from input-output data requires solving a non-convex optimization problem that is highly sensitive to initialization. Consequently, existing methods often rely on many random initializations. Instead, our work proposes an initialization strategy based on the Best Linear Approximator (BLA). Furthermore, motivated by an analysis of the impact of rational-dependency LPV-LFR models on the conditioning of the non-convex cost, two multiple shooting methods that improve the conditioning, unconstrained multiple shooting (UMS) and encoder-based multiple shooting (EBMS), are compared. The initialization and multiple shooting methods are evaluated on a nonlinear mass-spring-damper example, showing that BLA initialization consistently yields accurate results, whereas random initialization has a large spread. The results also show that both UMS and EBMS reduce the spread for randomly initialized models. UMS is simple to tune and well suited to few sub-records, whereas EBMS can exploit many short sub-records to further improve conditioning, at the cost of training an encoder and tuning additional hyperparameters.
Sources
- Efficient identification of linear, parameter-varying, and nonlinear systems with noise models
- Efficient Learning of Affine and Rational Dependency LPV Models With Linear Fractional Representation
- Learning neural state-space models: do we need a state estimator?
Related papers
- Industrial Load Modeling and Optimization for Market-Based Interaction with Power Systems
- Exact and Approximate Convex Reformulation of Linear Stochastic Optimal Control with Chance Constraints
- Certified Set Convergence for Piecewise Affine Systems
- Symbolic Control for Stochastic Systems via Finite Parity Games
- Multiobjective optimization-based design and dispatch of islanded, hybrid microgrids for remote, off-grid communities in sub-Saharan Africa
- Physiology-informed layered sensing for intelligent human-exoskeleton interaction