Main Content

Tree-partitioned nonlinear function for nonlinear ARX models

A `treepartition`

object implements a tree-partitioned nonlinear
function, and is a nonlinear mapping function for estimating nonlinear ARX models. The mapping
function, which is also referred to as a *nonlinearity*, uses a
combination of linear weights, an offset and a nonlinear function to compute its output. The
nonlinear function contains `treepartition`

unit functions
that operate on a radial combination of inputs.

Mathematically, `treepartition`

is a nonlinear function $$y=F(x)$$ that maps *m* inputs
*X*(*t*) =
[*x*(*t*_{1}),*x*_{2}(*t*),…,*x _{m}*(

$$F(x)=xL+[1,x]{C}_{k}+d$$

Here, *x* belongs to the partition
*P _{k}*.

`m`

+1 vector, and
For more information about the mapping function *F*(*x*)
see Algorithms.

Use `treepartition`

as the value of the `OutputFcn`

property of an `idnlarx`

model. For example, specify
`treepartition`

when you estimate an `idnlarx`

model with the
following
command.

sys = nlarx(data,regressors,treepartition)

`nlarx`

estimates the model, it essentially estimates the parameters
of the `treepartition`

function.
You can configure the `treepartition`

function to fix parameters. To omit
the linear component, set `LinearFcn.Use`

to `false`

. Use
`evaluate`

to compute the output of the function for a given vector of
inputs.

creates a
`T`

= treepartition`treepartition`

object `t`

that is a binary tree
nonlinear mapping object. The function computes the number of tree nodes
*J*, represented by the property `NumberOfUnits`

,
automatically during estimation. The tree has the number of leaves equal to
`2^(J+1)-1`

.

specifies the number of `T`

= treepartition(`numUnits`

)`treepartition`

nodes
`numUnits`

.

The mapping *F* is defined by a dyadic partition *P* of
the *x*-space, such that on each partition element
*P _{k}*,

$$F(x)=xL+[1,x]{C}_{k}+d$$

where *L* is 1-by-*m* vector and
*d* is a scalar common for all elements of partition.
*C*_{k} is a 1-by-(*m*+1)
vector.

The mapping *F* and associated partition *P* of the
*x*-space are computed as follows:

Given the value of

*J*, a dyadic tree with*J*levels and*N*= 2^{J–1}nodes is initialized.Each node at level 1 <

*j*<*J*has two descendants at level*j*+ 1 and one parent at level*j*– 1.The root node at level 1 has two descendants.

Nodes at level

*J*are terminating leaves of the tree and have one parent.

One partition element is associated to each node

*k*of the tree.The vector of coefficients

*C*is computed using the observations on the corresponding partition element_{k}*P*by the penalized least-squares algorithm._{k}When the node

*k*is not a terminating leaf, the partition element*P*_{k}is cut into two to obtain the partition elements of descendant nodes. The cut is defined by the half-spaces (1,*x*)*B*> 0 or <=0 (move to left or right descendant), where_{k}*B*is chosen to improve the stability of least-square computation on the partitions at the descendant nodes._{k}

When the value of the mapping

*F*, defined by the`treepartition`

object, is computed at*x*, an adaptive algorithm selects the*active node**k*of the tree on the branch of partitions that contain*x*.

When the `Focus`

option in `nlarxOptions`

is `'prediction'`

,
`treepartition`

uses a noniterative technique for estimating parameters.
Iterative refinements are not possible for models containing this nonlinearity
estimator.

You cannot use `treepartition`

when `Focus`

is
`'simulation'`

because this nonlinear mapping object is not differentiable.
Minimization of simulation error requires differentiable nonlinear functions.

`customnet`

| `evaluate`

| `idnlarx`

| `linear`

| `linearRegressor`

| `neuralnet`

| `nlarx`

| `polynomialRegressor`

| `sigmoidnet`

| `wavenet`