If a smoothed cubic spline is fitted to the same noisy dataset, the general sense of the data is captured without the spline mimicking the noise.

Understanding Smoothing Cubic Splines

Both cubic splines and cubic smoothing splines are constrained to have contiguous first and second derivatives, however only (interpolating) cubic splines are required to pass though all data points. Freed of these N data-point constraints, new additional constraints are now needed to have a fully determined solution. In the case of cubic smoothing splines we have the following two functional constraints: one which minimizes the squared error between the data and spline, and a second which minimizes the curvature.

To minimize the squared error we minimize the following function, where the yi‘s are the data’s ordinates, and the g(x)‘s are cubic polynomials.

To minimize the curvature we minimize:

Since we are not concerned with the convexity or concavity of the curvature, only the amount of curvature, we square the curvature eliminating the sign.

For most data sets, these two constraint functions act in opposition to one another. The first constraint pushes the spline as close as possible to the data points while the second attempts to keep the spline as free of curvature as possible. In the final formulation, these two countervailing constraints are joining by a weighting parameter, p, which balances these two opposing constraints and results in a smoothing cubic spline.

The two degenerate cases are worth pondering. If p = 1 the curvature constraint is nullified and the smoothing cubic spline then passes through all data points resulting in an interpolation spline. In other words, with p = 1 we have reverted back to a natural cubic spline solution. If p = 0 only the curvature of the spline is minimized. Therefore we are minimizing the mean squared error over linear functions resulting in a linear (straight-line) least squares fit. A few smoothing cubic splines are shown below demonstrating the effect of various choices of p.

Smoothing Cubic Splines C# code example.

The NMath library currently supports two spline classes for natural and clamped splines. The class SmoothCubicSpline is not currently released but will be available in the spring 2014 release of NMath 6.0. If you have a need for this class before our next release, please contact us.

The following example code creates a noisy sinusoid signal then generates a smoothing cubic spline fit and finally charts the results.

   // Build a noisy signal to fit with the smooth cubic spline.
   var numPoints = 64;
   x = new DoubleVector( numPoints, 0, 2.0 * Math.PI / ( numPoints - 1.0 ) );
   yNoisy = new DoubleVector( numPoints );
   RandGenUniform rng = new RandGenUniform( 0x162 );
   for ( int i = 0; i < x.Length; i++ )
   {
     yNoisy[i] = ( 2.3 * Math.Cos( 3.0 * x[i] ) + 
                   1.2 * Math.Sin( 4.5 * x[i] ) + 
                   Math.Cos( 1.92 * x[i] ) ) + rng.Next();
   }

   // Compute the cubic smoothing spline.
   double p = 0.75;
   SmoothCubicSpline spline = new SmoothCubicSpline( x, yNoisy, p );

   // Chart the noisy signal and smoothing spline.
   var numInterpolatedValues = 512;
   var chart = NMathChart.ToChart( spline, numInterpolatedValues );
   chart.Titles.Add( String.Format( "Smoothed Cubic Spline with P = {0}", p.ToString() ) );
   chart.Series[0].Name = "Noisy Data";
   chart.Series[1].Name = "Spline";

   NMathChart.Show( chart );

The above code was used to generate the following four charts which compare cubic spline fits of the same dataset with different weighting factors. The four weighting factors used were p = 0.05, 0.5, 0.75, 0.98.

It’s worth noting that if you need to filter uniformly sampled data Savitzky-Golay filters work similarly to a cubic smoothing spline by fitting piecewise continuous polynomials to the data. To more learn about Savitzky-Golay filtering have a look at our blog article.

-Happy Computing,

Paul Shirkey

References
P. Craven and G. Wahba, “Smoothing Noisy Data with Spline Functions”, Numerische Mathematik, vol. 31, pp. 377-403, 1979.

The post Smoothing Cubic Splines appeared first on CenterSpace.

Free Project Examples

As part of of this partnership our software engineers are working together to develop a series of example applications to help our customers quickly become productive using our tool set. Our first example demonstrates how to use the Nevron .NET chart component with some of NMath Stat’s fundamental capabilities: regression and prediction, polynomial curve fitting, and data smoothing. To build and run this example, you’ll need to download this VS8 project, along with evaluation copies of the CenterSpace NMath Suite and the Nevron .NET Chart package. All of this is freely available from our partnership page.

As I mentioned this is the first in a series of examples that we will be jointly developing. Our next example application is in the planning stages, and will cover the building of common charts in statistical process control. Statistical process control is employed across many industries ranging from manufacturing to medicine and has been an area of interest by customers of both companies. We’ll post up a blog article about the example once it’s finished and you’ll see a tweet about it if you are following us.

If you have an idea for an example using Nevon’s and CenterSpace’s tools together, which would help speed along your own project, leave a comment or drop us an email. We just may cook it up!

Discount Bundle

As part of our partnership with Nevron, we are able to offer a substantial discount on package licenses. If you are interested, please email our sales staff and request the Nevron partnership discount.

Thanks for reading,

-The CenterSpace Team

Resources

• CenterSpace partnership information partnership page.
• Nevron technology partnership information page.
• Nevron’s .NET Chart home page.

The post Nevron Partnership appeared first on CenterSpace.

Algorithm

Savitzky-Golay locally smooths a signal by fitting a polynomial, in a least squares sense, to a sliding window of data. The degree of the polynomial and the length of the sliding window are the filter’s two tuning parameters. If n is the degree of the polynomial that we are fitting, and k is the width of the sliding window, then

For the case of n=0 the Savitzy-Golay filter degenerates to a moving average filter – which is good for removing white noise, but is poor for preserving peak shape (higher order moments). For n=1, the filter does a linear least-squares fit of the windowed data to a line. If n=k-1, the polynomial exactly fits data point in the window, and so no filtering takes place.

Once the polynomial is fit, then (typically) the center data-point in this window is replaced by value of the polynomial at that location. The window then slides to the right one sample and the process is repeated.

Savizky-Golay delivers the unexpected surprise that the polynomial fitting coefficients are constant for a given n and k. This means that once we fix n and k for our filter, the Savizky-Golay polynomial fitting coefficients are computed once during setup and then used across the entire data set. This is why Savizky-Golay is a high performance correlation filter.

Comparison Example

The following three images show some real experimental data and a comparison of two filtering algorithms. The first image shows the raw data, the second image shows the effect of an averaging filter, and the last image demonstrates a Savitzky-Golay smoothing filter of length five.

The averaging filter introduces a large error into the location of the orange peak whereas Savitzky-Golay removes the noise while maintaining the peak location. Computationally, they require identical effort.

Savitzky-Golay Smoothing in C#

The Savitzky-Golay smoothing filter is implemented in the NMath-Stats package as a generalized correlation filter. Any filter coefficients can be used with this moving window filter, Savitzky-Golay coefficients are just one possibility. The moving window filter also does not require the filtering to take place in the center of the sliding window; so when specifying the window, two parameters are required: number to the left, and number to the right of the filtered data point.

Here are the key software components.

The first is a static function for generating the Savizky-Golay coefficients, the second is the filtering class that takes the generated coefficients in the constructor. The third is the method that does the Savitzky-Golay filtering by running a cross-correlation between the data the the saved coefficients.

Below is a complete code example to copy and experiment with your own data sets. Only three lines of code are needed to build the filter and actually do the filtering. The remaining code builds a synthetic noisy signal to filter and displays the results.

int nLeft = 2;
int nRight = 2;
int n = 3;

// Generate the coefficients.
DoubleVector c =
MovingWindowFilter.SavitzkyGolayCoefficients( nLeft, nRight, n );

// Build the filter of width: nLeft + nRight + 1
MovingWindowFilter filter =
  new MovingWindowFilter( nLeft, nRight, c );
Console.WriteLine( "Filter coeffs = " + filter.Coefficients );

// Generate a signal
DoubleVector x = new DoubleVector( 100, -5, .1 );
DoubleVector y = new DoubleVector( x.Length );
for ( int i = 0; i < x.Length; i++ )
{
  double a = x[i];
  y[i] = 0.03*Math.Pow(a, 3) + 0.2*Math.Pow(a, 2) -.22*a + 0.5;
}
Console.WriteLine( "Smoothed signal = " + y );

RandGenUniform rng = new RandGenUniform(-1, 1, 0x124 );
for ( int i = 0; i < y.Length; i++ )
{
  y[i] += rng.NextDouble();
}
Console.WriteLine( "x = " + x );
Console.WriteLine( "Noisy signal = " + y );

// Do the filtering.
DoubleVector z =
filter.Filter(y, MovingWindowFilter.BoundaryOption.PadWithZeros);
Console.WriteLine( "Signal filtered = " + z );

-Paul

Addendum – Savitzky-Golay Coefficients

If you want to quickly try out Savitzky-Golay smoothing without computing the coefficients, or just compare coefficients, here are some coefficients for a sliding window of length five. They also provide some insight into the relationship between the coefficients and the behavior of the filter.

Filter length = 5, nLeft = 2, nRight = 2.
Polynomial of order 0,
[ 0.2 0.2 0.2 0.2 0.2 ]  (averaging filter)
Polynomial of order 1,
[ 0.2 0.2 0.2 0.2 0.2 ]
Polynomial of order 2,
[ -0.0857142 0.3428571 0.4857142 0.3428571 -0.0857142 ]
Polynomial of order 3,
[ -0.0857142 0.3428571 0.4857142 0.3428571 -0.0857142 ]
Polynomial of order 4 and higher,
[ 0 0 1 0 0 ]  (as expected, no filtering here!)

Another Smoothing Example on Real Data

This is another example of Savitzky-Golay smoothing on some experimental data. If more smoothing was desired, a longer filtering window could have been used.

The post Savitzky-Golay Smoothing in C# appeared first on CenterSpace.