TP Model Transformation In Control Theory

Baranyi and Yam proposed the TP model transformation as a new concept in quasi-LPV (qLPV) based control, which plays a central role in the highly desirable bridging between identification and polytopic systems theories. It is also used as a TS (Takagi-Sugeno) fuzzy model transformation. It is uniquely effective in manipulating the convex hull of polytopic forms (or TS fuzzy models), and, hence, has revealed and proved the fact that convex hull manipulation is a necessary and crucial step in achieving optimal solutions and decreasing conservativeness in modern linear matrix inequality based control theory. Thus, although it is a transformation in a mathematical sense, it has established a conceptually new direction in control theory and has laid the ground for further new approaches towards optimality.

For details please visit: TP model transformation.

;TP-tool MATLAB toolbox:

A free MATLAB implementation of the TP model transformation can be downloaded a

or an old version of the toolbox is available at MATLAB Centra

Be careful, in the MATLAB toolbox the assignments of the dimensions of the core tensor is in the opposite way in contrast to the notation used in the related literature. In some variants of the ToolBox, the first two dimension of the core tensor is assigned to the vertex systems. In the TP model literature the last two. A simple example is given below.

clear
M1=20; 		% Grid density
M2=20;
omega1= 1,1 		%Interval 
omega2= 1,1
domain= mega1; omega2
for m1=1:M1
    for m2=1:M2
        p1=omega1(1)+(omega1(2)-omega1(1))/M1*(m1-1); 	%sampling grid
        p2=omega2(1)+(omega2(2)-omega2(1))/M2*(m2-1);
        SD(m1,m2,1,:)=  0				% SD is the discretized system matrix
        SD(m1,m2,2,:)= -1-0.67*p1*p1) (1.726*p2*p2)
    end
    end
 ,U, svhosvd(SD, ,1,0,01e-12);		% Finding the TP structure
UA=U;					% This is the HOSVD based canonical form
UA=U;
ns1 = input('Results of SNNN TS fuzzy model');
UC=genhull(UA,'snnn'); 				% snnn weightinf functions
UCP=pinv(UC);
UCP=pinv(UC);
SC=tprods(SD,UCP);  				%This is to find  the core tensor 
H(:,:)=SC(1,1,:,:)                              %This is to show the vertices of the TP model
H(:,:)=SC(1,2,:,:)
H(:,:)=SC(2,1,:,:)
H(:,:)=SC(2,2,:,:)
figure(1) 
hold all 
plothull(U, omega1)                          %Draw the waiting functions of p1
title('Weighting functions for p_');
xlabel('p_')
ylabel('Weighting functions')
grid on
box on
figure(2) 
hold all 
plothull(UC, omega2)                         %Show the waiting functions of p2
title('Weighting functions for p_');
xlabel('p_')
ylabel('Weighting functions')
grid on
box on
ns2 = input('Results of CNO TS fuzzy model');
UC=genhull(UA,'cno');                          %Create CNO type waiting functions 
UCP=pinv(UC);
UCP=pinv(UC);
SC=tprods(SD,UCP);                             %Find the cortensor
H(:,:)=SC(1,1,:,:)                             %Show the vertices of the TP model
H(:,:)=SC(1,2,:,:)
H(:,:)=SC(2,1,:,:)
H(:,:)=SC(2,2,:,:)
figure(1) 
hold all 
plothull(U, omega1)                         %Show the waiting functions of p1
title('Weighting functions for p_');
xlabel('p_')
ylabel('Weighting functions')
grid on
box on
figure(2) 
hold all 
plothull(UC, omega2)                        %Show the waiting functions of p2
title('Weighting functions for p_');
xlabel('p_')
ylabel('Weighting functions')
	Once you have the feedback vertexes derived to each vertexes of the TP model then you may want to calculate the controller over the same polytope (see PDC design by Tanaka)
W = queryw1(UC,domain,p);  % computing the weighting values over the parameter vector
F = tprods(K,W);		% calculating the parameter dependent feedback F(p)
F = shiftdim(F)
U=-F*x				% calculate the control value.

Key features for control analysis and design

* The TP model transformation transforms a given qLPV model into a (tensor product type) polytopic form, irrespective of whether the model is given in the form of analytical equations resulting from physical considerations, or as an outcome of soft computing based identification techniques (such as neural networks or fuzzy logic based methods, or as a result of a black-box identification).
* Further the TP model transformation is capable of manipulating the convex hull defined by the polytopic form that is a necessary step in polytopic qLPV model-based control analysis and design theories.

Related definitions

;Linear Parameter-Varying (LPV) state-space model:

::$\begin (t) \\ (t) \end=((t))\begin (t) \\ (t) \end,$

with input $(t)$, output $(t)$ and state
vector $(t)$. The system matrix $((t))\in\R^$ is a parameter-varying object, where $(t)\in\Omega$ is a time varying $N$-dimensional parameter vector which is an element of
closed hypercube \Omega=
_1,b_1times _2,b_2times\cdots\times _N,b_Nsubset\R^N. As a matter of fact, further parameter dependent channels can be inserted to $((t))$ that represent various control performance requirements.

;quasi Linear Parameter-Varying (qLPV) state-space model:

$(t)$ in the above LPV model can also include some elements of the state vector
$(t)$, and, hence this model belongs to the class of non-linear systems, and is also referred to as a quasi LPV (qLPV) model.

;TP type polytopic Linear Parameter-Varying (LPV) state-space model:

::$\begin (t) \\ (t) \end=\mathcal\boxtimes_^N\mathbf_n(p_n(t))\begin (t) \\ (t) \end,$

with input $(t)$, output $(t)$ and state
vector $(t)$. The system matrix $((t))=\mathcal\boxtimes_^N\mathbf(p_n(t)) \in\R^$ is a parameter-varying object, where $(t)\in\Omega$ is a time varying $N$-dimensional parameter vector which is an element of
closed hypercube \Omega=
_1,b_1times _2,b_2times\cdots\times _N,b_Nsubset\R^N, and the weighting functions w_(p_n(t))\in ,1/math> are the elements of vector $\mathbf_n(p_n(t))$. Core tensor contains elements $\mathbf_$ which are the vertexes of the system.
As a matter of fact, further parameter dependent channels can be inserted to $((t))$ that represent various control performance requirements.
Here

:: $\forall n : \sum_^ w_(p_n(t)) = 1.$ and w_(p_n(t)) \in ,1.

This means that $\mathbf((t))$ is within the vertexes $\mathbf_$ of the system (within the convex hull defined by the vertexes) for all $\mathbf(t) \in \Omega$.
Note that the TP type polytopic model can always be given in the form

:: $\mathbf(\mathbf(t))=\sum_^R \mathbf_r w_r(\mathbf(t)),$

where the vertexes are the same as in the TP type polytopic form and the multi variable weighting functions are the product of the one variable weighting functions according to the TP type polytopic form, and r is the linear index equivalent of the multi-linear indexing $i_1,i_2, \ldots i_N$.

;TP model transformation for qLPV models:
Assume a given qLPV model $\mathbf(\mathbf(t))$, where $\mathbf(t)\in \Omega \subset R^N$, whose TP polytopic structure may be unknown (e.g. it is given by neural networks). The TP model transformation determines its TP polytopic structure as

:: $\mathbf(\mathbf(t))=\mathcal\boxtimes_^N\mathbf_n(p_n(t))$,

namely it generates core tensor $\mathcal$ and weighting functions of $\mathbf_n(p_n(t))$ for all $n=1 \ldots N$. Its free MATLAB implementation is downloadable a

or at MATLAB Centra

If the given model does not have (finite element) TP polytopic structure, then the TP model transformation determines its approximation:

:: $\mathbf(\mathbf(t)) \approx \mathcal\boxtimes_^N\mathbf_n(p_n(t)),$

where trade-off is offered by the TP model transformation between complexity (number of vertexes stored in the core tensor or the number of weighting functions) and the approximation accuracy. The TP model can be generated according to various constrains. Typical TP models generated by the TP model transformation are:
* HOSVD canonical form of qLPV models,
* Various kinds of TP type polytopic form (this feature is very important in control performance optimization).

TP model based control design

;Key methodology:

Since the TP type polytopic model is a subset of the polytopic model representations, the analysis and design methodologies developed for polytopic representations are applicable for the TP type polytopic models as well.
One typical way is to search the nonlinear controller in the form:

:: $u=-\mathbf(\mathbf(t))\mathbf(t)=-\sum_^R F_r w_r(\mathbf(t))\mathbf(t),$

where the vertexes $\mathbf_r$ of the controller is calculated from $\mathbf_r$. Typically, the vertexes $\mathbf_r$ are substituted into Linear Matrix Inequalities in order to determine $\mathbf_r$.

In TP type polytopic form the controller is:

:: $u=-\mathbf(\mathbf(t))\mathbf(t)=-\mathcal\boxtimes_^N\mathbf_n(p_n(t))\mathbf(t),$

where the vertexes $\mathbf_$ stored in the core tensor $\mathcal$ are determined from the vertexes $\mathbf_$ stored in $\mathcal$. Note that the polytopic observer or other components can be generated in similar way, such as these vertexes are also generated from $\mathcal$.

;Convex hull manipulation based optimization:

The polytopic representation of a given qLPV model is not invariant. I.e. a given $\mathbf(\mathbf(t))$ has $Z=\infty$ number of different representation as:

:: $\mathbf(\mathbf(t))=\mathcal_z\boxtimes_^N\mathbf_(p_n(t)),$

where $z=1\ldots Z$. In order to generate an optimal control of the given model $\mathbf(\mathbf(t))$ we apply, for instance LMIs. Thus, if we apply the selected LMIs to the above polytopic model we arrive at:

:: $u_z=-\mathbf_z(\mathbf(t))\mathbf(t)=-\mathcal_z\boxtimes_^N\mathbf_(p_n(t))\mathbf(t).$

Since the LMIs realize a non-linear mapping between the vertexes in $\mathcal$ and $\mathcal$ we may find very different controllers for each $z=1\ldots Z$. This means that we have $Z$ different number of "optimal" controllers to the same system $\mathbf(\mathbf(t))$. Thus, the question is: which one of the "optimal" controllers is really the optimal one. The TP model transformation let us to manipulate the weighting functions systematically that is equivalent to the manipulation of the vertexes. The geometrical meaning of this manipulation is the manipulation of the convex hull defined by the vertexes. We can easily demonstrate the following facts:

* Tightening the convex hull typically decreases the conservativeness of the solution, so as may lead to better control performance. For instance, if we have a polytopic representation

:: $\mathbf(\mathbf(t))=\mathcal\boxtimes_^N\mathbf_(p_n(t)),$

of a given model $\mathbf(\mathbf(t))$, then we can generate a controller as

:: $u=-\mathcal\boxtimes_^N\mathbf_(p_n(t))\mathbf(t),$

then we solved the control problem of all systems $k=1\ldots K=\infty$ that can be given by the same vertexes, but with different weighting functions as:

:: $\mathbf_k(\mathbf(t))=\mathcal\boxtimes_^N\mathbf_(p_n(t)),$

where

:: $u_k=-\mathcal\boxtimes_^N\mathbf_(p_n(t))\mathbf{x}(t).$

If one of these systems are very hardly controllable (or even uncontrollable) then we arrive at a very conservative solution (or unfeasible LMIs). Therefore, we expect that during tightening the convex hull we exclude such problematic systems.

* It can also be easily demonstrated that the observer design is typically needs large convex hull. So, as when we design controller and observer we need to find the optimal convex hull between the tight one and the large one. Same papers also demonstrate that using different convex hulls (if the separation principal is applicable) for observer and controller may lead to even better solution.

Properties of the TP model transformation in qLPV theories

* It can be executed uniformly (irrespective of whether the model is given in the form of analytical equations) resulting from physical considerations, or as an outcome of soft computing based identification techniques (such as neural networks or fuzzy logic based methods, or as a result of a black-box identification), without analytical interaction, within a reasonable amount of time. Thus, the transformation replaces the analytical and in many cases complex and not obvious conversions to numerical, tractable, straightforward operations that can be carried out in a routine fashion.
* It generates the HOSVD-based canonical form of qLPV models, which is a unique representation. This form extracts the unique structure of a given qLPV model in the same sense as the HOSVD does for tensors and matrices, in a way such that:
:* the number of LTI components are minimized;
:* the weighting functions are one variable functions of the parameter vector in an orthonormed system for each parameter (singular functions);
:* the LTI components (vertex components) are also in orthogonal positions;
:* the LTI systems and the weighting functions are ordered according to the higher-order singular values of the parameter vector;
:* it has a unique form (except for some special cases);
:* introduces and defines the rank of the qLPV model by the dimensions of the parameter vector;

* The core step of the TP model transformation was extended to generate different types of convex polytopic models, in order to focus on the systematic (numerical and automatic) modification of the convex hull instead of developing new LMI equations for feasible controller design (this is the widely adopted approach). It is worth noting that both the TP model transformation and the LMI-based control design methods are numerically executable one after the other, and this makes the resolution of a wide class of problems possible in a straightforward and tractable, numerical way.
* Based on the higher-order singular values (which express the rank properties of the given qLPV model, see above, for each element of the parameter vector in $L_2$ norm), the TP model transformation offers a trade-off between the complexity of the TP model (polytopic form), hence, the LMI design and the accuracy of the resulting TP model.
* The TP model transformation is executed before utilizing the LMI design. This means that when we start the LMI design we already have the global weighting functions and during control we do not need to determine a local weighting of the LTI systems for feedback gains to compute the control value at every point of the hyperspace the system should go through. Having predefined continuous weighting functions also ensures that there is no friction in the weighting during control.

References

Control theory