buntonj / polynomial_observers Goto Github PK

Savitzky-Golay filtering uses polynomials (in time) as a basis and fits them to windows of data. As the polynomial degree grows, however, this fitting can become ill-conditioned.

We could instead use simulation traces of the nonlinear ODE as a basis, and fit linear combinations of the simulation traces to the output trajectory. This could be more well-posed (and tailored to the system), at the cost of having to simulate the system.

Re-implement with numpy's built-in polynomial fitting tools, rather than home-brewed versions I wrote.

Currently only compares directly in output space. For integrator systems, this map is the identity, but other nonlinear systems will need more custom maps

examples:

• TORA system
• Lorenz attractor

We proved that there is a function from polynomial fitting residual to estimation error, also proved a global "flat-line" bound on the estimation error. Need to see how tight these bounds are in some examples so we can see how useful they might be in practice

currently, we use the map guaranteed by differential observability to invert outputs + derivatives to states, but under linear outputs we may be able to directly invert any polynomial output trajectory into a polynomial state trajectory to make regression easier.

Right now, simulation fitting error bound requires stepping through polynomial error bound. Can we make one that is indpendent?

ODE examples are currently just a pile of function handles. Should convert to classes with member functions, then hand these class objects to the regression/fitting classes for easier access to things like "output inversion" and "output derivative" expressions

Choice of subset $\mathcal{D}$ impacts the effects of noise on the theoretical guarantees. Need to allow for flexible choices of this subset in simulation so that we can smooth the effects of noise in the guarantee as well.

Analyze how noisy signals impact the guarantee we can give. Can we do some sort of "mollification" or smoothing like Grizzle/Diop suggest? If so, how does that impact the guarantee?

Add process to optimize the bound expression over all choices of integer inter-sample spacings.

Right now outputs must be a single scalar, need to add support for fitting multi-dimensional polynomials up to a given degree

For numerical stability, fit and differentiate the polynomials with centered values. Fitting might already be implemented by numpy's polynomial class (check).

When using this for control, we will need to evolve the state estimate forward in time to accommodate the delay caused by this approach.

Need to clean and update the write up to include all aspects of the theory we've written so far.

Write a Mathematica script to compute the value of the bound for a given polynomial degree $d$ and derivative query $k$ as an algebraic expression in terms of the least-squares residual and inter-sample distance.

Prove (or disprove) estimation error is bounded by a $\mathcal{K}_\infty$ function of the least-squares residual.

Right now we just have a few dummy ODE's with no inputs. Try some more exciting robots:

• #19
• Inverted pendulum
• Euler-Lagrange eq's in some standard form? (stepping toward the dog)

Ackerman model contains angle states, which need to be wrapped to live within $$(-\pi, \pi )$$. This should likely be handled by the SYSTEM object, which should likely contain a "get/set" method for the current state and input which we can then modify for state wrapping/formatting in the future.

Currently, bound relies on dividing powers of $\delta$ with $(d+1)!$ which is numerically unstable. Could try and connect some of the parameters and make the bound computations more numerically stable in practice.