Question

I have a set of sensor signal samples (containing roughly 10 readings that both contain X,Y and Z axis readings) that I am using as a training set, let’s call the set (s1). The program is constantly listing to sensor signals every 2 seconds which we will call (h1). Now, what I want to do is use h1 (which contains a single signal reading) and match that against the training set of signals (s1).

So from (s1), the signal that is most similar to (h1) (strong similarities such as signal peak, peak level etc..).

Could this easily be done using Neural Networks? Anything particular to look out for when dealing with signals? fourier transform?

If Neural Networks is the way to go, any particular algorithm that would be ideal with this sort of data. I’m currently making an application that assesses road surfaces using an accelerometers data.

An example of a signal I am dealing with is this below.

Date= 1/1/2012 (dd:mm:yyyy) Time= 1:45:2 (hh:mm:ss)
Speed Bump Recording Started at 1:45:2 (hh:mm:ss)
X-Value = -0.141905, Y-Value = 8.436457, Z-Value = 5.019961, Timestamp(milliseconds) = 75002
X-Value = -0.218546, Y-Value = 8.244855, Z-Value = 4.828360, Timestamp(milliseconds) = 75201
X-Value = 0.317939, Y-Value = 8.781339, Z-Value = 4.866680, Timestamp(milliseconds) = 75401
X-Value = 0.088017, Y-Value = 8.014933, Z-Value = 4.981641, Timestamp(milliseconds) = 75602
X-Value = 0.011376, Y-Value = 7.976613, Z-Value = 5.633086, Timestamp(milliseconds) = 75802
X-Value = 0.164658, Y-Value = 8.934620, Z-Value = 4.790039, Timestamp(milliseconds) = 76001
X-Value = -0.141905, Y-Value = 8.474776, Z-Value = 3.985312, Timestamp(milliseconds) = 76202
X-Value = 0.432900, Y-Value = 8.781339, Z-Value = 4.636758, Timestamp(milliseconds) = 76402
X-Value = -0.141905, Y-Value = 9.471105, Z-Value = 4.138594, Timestamp(milliseconds) = 76601
X-Value = 0.202978, Y-Value = 8.704699, Z-Value = 3.525469, Timestamp(milliseconds) = 76800
X-Value = 0.394579, Y-Value = 7.440128, Z-Value = 3.640430, Timestamp(milliseconds) = 77001
X-Value = -0.448467, Y-Value = 6.903644, Z-Value = 4.023633, Timestamp(milliseconds) = 77203
X-Value = -0.640069, Y-Value = 11.195518, Z-Value = 9.005274, Timestamp(milliseconds) = 77401
X-Value = -0.065264, Y-Value = 5.945636, Z-Value = 4.176914, Timestamp(milliseconds) = 77604
X-Value = -0.755030, Y-Value = 9.317823, Z-Value = 4.675078, Timestamp(milliseconds) = 77801
X-Value = -0.563428, Y-Value = 8.896300, Z-Value = 5.824687, Timestamp(milliseconds) = 78003
X-Value = -0.410147, Y-Value = 8.014933, Z-Value = 5.211563, Timestamp(milliseconds) = 78201
X-Value = -0.371827, Y-Value = 8.168214, Z-Value = 5.173242, Timestamp(milliseconds) = 78401
Speed Bump Recording Stopped at 1:45:6 (hh:mm:ss)

Answer 1

Not sure I understand the question exactly. If you’re looking to find the single entry in s1 that’s closest to the single reading h1, and each of the X, Y, and Z components is equally important, then you can

• scan through the list of elements in s1,
• compute an error value for each, and
• choose the one with the smallest error.

If sx, sy, sz are the components of an element from s1, and hx, hy, hz are the components of h1, then you can calculate:

error = (sx - hx)^2 + (sy - hy)^2 + (sz - hz)^2

Geometrically, you can interpret this as finding the element in s1 that would be closest to the reading h1 if you plotted all the points in 3D space. The error value is the square of the distance between the element in s and h.

---

On the other hand, if you’re looking to find the best match between sequences of points, you’ll want to use a cross-correlation. To do this, you’d do a component-wise multiplication of each element in one sequence with the corresponding element of the other, sum all of the products, and divide by the length of the sequence. The larger the final result, the closer the sequences match.

If the first sequence contains the points A1, A2, A3, …, An
And the second sequence contains the points B1, B2, B3, …, Bn
And each point contains an x, y, and z component, then you’d calculate:

C(A,B) = [  (A1x * B1x) + (A1y * B1y) + (A1z + B1z) 
          + (A2x * B2x) + (A2y * B2y) + (A2z * B2z)
          ...
          + (Anx * Bnx) + (Any * Bny) + (Anz * Bnz)
         ] / n