-
Welcome to Module 5.2.
-
In the previous module, we introduced the concept of filtering and that of convolution.
-
In this module, we will see some filtering in action by setting up a mock problem
-
where we try to remove some noise from the signal.
-
The two characters that we will introduce in this chapter
-
are two friends that will remain with us for a very long time:
-
the Moving Average and the Leaky Integrator.
-
Hi, and welcome to Module 5.2 of Digital Signal Processing,
-
in which we will talk about filters, by showing some filtering examples.
-
In particular, we will introduce two characters
-
that will remain with us until the end of the class,
-
the Moving Average filter and the Leaky Integrator.
-
So, in the previous module,
-
we talked a lot about the properties of Linear Time Invariant filters,
-
but we haven't said much about the applications that can be addressed by using filters.
-
So here, let me give you an example.
-
Suppose you're taking measurements of a physical quantity
-
that you know to be smooth and slowly varying:
-
for instance, the tide level at the sea or the blood pressure of a patient.
-
Because of the measurement process,
-
your values, the values that you actually measure,
-
are corrupted by some form of additive noise.
-
Which at this point, we could just say
-
it's some extraneous quantity that perturbs the measured value.
-
So, what you get in the end, instead of the smooth curve of the first panel,
-
is a curve where you see that there's really fast wiggles
-
that you interpret as being a noise corruption.
-
And the question is, can we process this data as a discrete time signal
-
so that most of the noise is removed and we get back a measurement
-
that is in line with our expectations of smoothness?
-
The first idea is to replace each sample of the input sequence
-
with a local average.
-
Averages are usually good when you want to eliminate random variations
-
that you don't know much about.
-
So, for instance, assume a situation where we process the signal
-
and the process (? processed?) signal is at each sample,
-
the simple two-point average of the current sample and the past sample.
-
Well, it could very well be that the two-point average
-
is not enough to remove most of the noise.
-
And so, in general, we could take longer averages
-
by considering the output samples to be the average of M points from the input.
-
If we try to do that experimentally, we can see immediately
-
that the strategy works for increasing values of M.
-
So, if we take just a two-point average,
-
we see that we don't really get a lot of leverage(?).
-
You can see in blue the original signal, and in red the filtered output.
-
And with a two-point average, we still have a lot of wiggles.
-
But, as we increase the number of points that we use to compute the average,
-
we can see that we start to remove a little bit more of the noise.
-
And by a 12 point average, we already can see that the strategy actually pays off:
-
we have already smoothed out the signal quite significantly,
-
and if we're willing to increase the average up to, say, 100-point,
-
then we can see that the signal we get at the output is actually very smooth.
-
You will also see that, with respect to the original signal,
-
the output has been delayed by a certain amount.
-
This is the price we pay because we are actually using up 100 samples
-
to compute the output value.
-
So, in a sense, we're accumulating a certain delay with respect to the input
-
because we're averaging from the past.
-
We will see this in more detail later on.
-
What we have done is really a filtering operation.
-
And if we want to compute the impulse response, we need to do nothing more
-
than just put the δ function inside our averaging machine,
-
and it's very easy to see that if we put the δ function in here,
-
-- this is, remember, is the averaging relation that we saw before, --
-
we have that the impulse response is equal to 1/M for n that goes from 0 to M -1, and 0 otherwise.
-
It's easy to convince yourself that in this summation,
-
there's only one non-zero term, which is the one where n is equal to k.
-
Since the index goes from 0 to M-1,
-
if your value of n is outside of this range,
-
none of these terms will be nonzero and you will get 0.
-
If we plot the impulse response, it looks like this.
-
So, you will have a string of samples that are equal to 1/M from 0 to M-1.
-
So, what we have learned experimentally is that the smoothing effect of the filter
-
is proportional to the length of the impulse response.
-
As a consequence of that, a number of operations that we have to perform
-
to compute each output sample, and also the storage
-
-- because we have to keep in the memory of our processing unit
-
the past values in order to be able to compute the average --
-
well, both of these quantities are proportional to the length of the filter.
-
So, as the filter becomes longer and as its smoothing effect increases,
-
the price we pay in terms of computational resources and memory are higher.
-
So, we might not like that, and we might want to see
-
whether there's a smarter way to achieve the same effect
-
without using up so much in terms of computing power.
-
Let's look at the equation for the Moving Average.
-
It's just 1/M times the sum of input samples from n to n-M + 1.
-
Now, we can split this into two parts.
-
We have the first term,
-
which is 1/M times the current input
-
+ 1/M times the sum of past input samples from n-1 to n-M + 1.
-
And this is the sum of M-1 terms.
-
So, the second term here looks suspiciously close to the Moving Average,
-
computed this time over M-1 points.
-
So, 1 point less than before and delayed by 1.
-
So, it's close, but it is not quite the same thing,
-
so let's look at ways to formalize this relationship.
-
To do so, we first write out the standard equation for the Moving Average filter,
-
which we have seen before.
-
So, nothing new here.
-
Now, we try and compute the delayed output.
-
So, y of M of n-1 is the sum, it's 1/M times the sum from k that goes from 0 to M-1 of x[(n-1) - k].
-
We can rearrange the index of the signal like so,
-
and now this + 1 that affects only this emission (?) index
-
can be propagated to the summation range.
-
And we have that, if we delay the Moving Average by 1,
-
we basically just affect the range of the summation
-
that now goes from 1 to M, instead of from 0 to M-1.
-
Okay. Now, let's look at the formula for the Moving Average over M-1 point,
-
and this is just the Moving Average.
-
So, 1 over M-1 times the sum from k that goes to zero to M-2 of n[x - k].
-
And now we do the same, we try to delay this by one.
-
And again, this delay will propagate to the summation range.
-
And we will have the sum that goes now from k=1 to M-1.
-
So, formula for the Moving Average over M points.
-
And here, formula for the Moving Average over n-1 points, delayed by 1.
-
Alright, but now, if we take the sum of the input from zero to M-1,
-
we can split this as current sample + n-2 samples in the past.
-
and so, this part here corresponds to this and this part here corresponds to this, right?
-
So, we can swap terms and we obtain the relationship that we were looking for
-
between the Moving Average over M points,
-
and the Moving Average over M-1 points delayed by 1.
-
So, we have rearranged the terms
-
and we have that the Moving Average over M points in n is equal to
-
M-1 over n times the Moving Average over M-1 points delayed by 1, plus 1/M times x[n].
-
And so, if we want to write this a little bit better,
-
we define a parameter λ as M-1 over M,
-
and we have this final (?) relationship here.
-
Now, there's nothing new, what we saw so far.
-
We just rearranged terms in finite sums.
-
But, here comes the trick that defines the Leaky Integrator filter.
-
When M is very large, we assume that the average over M-1 or over M point (?)
-
is going to be pretty much the same:
-
not much is going to change if we add a single data point to a very long average.
-
And also, when M is very large, λ, which was defined as M-1 over M,
-
is going to be very close to 1.
-
So, we can rewrite the previous equation as current estimate for the Moving Average
-
is equal to λ times the previous estimate for a Moving Average
-
plus 1-λ times the current input.
-
And this defines a filter that we can use to process our signal.
-
Now, the filter is recursive because we're using output values,
-
previous output values, to compute the current value of the output.
-
So, there's a feedback path that goes from the output, back into the filter.
-
Before we even try to analyze this, let's see if it works.
-
So, we take our smooth signal corrupted by noise,
-
and we filter it with a Leaky Integrator for varying values of λ.
-
So, if we start with λ rather small, we don't really see much happening.
-
But, as we increase the value of λ towards 1,
-
which is really the operating assumption for the duration of the filter anyway,
-
we see that we start to smooth the signal as we expected.
-
And when λ is very close to 1, the smoothing power is comparable to that
-
of a Moving Average filter with a very high number of taps.
-
But now, the difference is that each output value only requires three operations
-
because remember, the value is simply one multiplication,
-
and then there's going to be another multiplication and one sum.
-
And this is independent of the value of λ.
-
So: high smoothing power at a fixed price.
-
Of course, the natural question when we have a filter
-
is what the impulse response is going to be
-
and to compute the impulse response of the Leaky Integrator,
-
all we need to do is to plug the δ function into the recursive equations,
-
and see what happens.
-
So, when n is less than 0, since the δ function is 0 from minus infinity to 0,
-
nothing "non-zero" has ever happened inside this equation.
-
And so, it's very safe to assume that the output will be zero for all values of n less than 0.
-
Things start to happen when n reaches zero.
-
At which point, the δ function kicks and assumes the value of one.
-
So, if we compute the value of the output for n equal to 0,
-
we have λ times the previous value of the output,
-
-- which we know to be 0, so this is 0 --
-
plus 1-λ times the value of δ and 0 (?δn0), which is 1.
-
And so, the output would be 1-λ.
-
At the next step, y[1] is equal to λ times the previous value of the output,
-
which now is not non-zero, it's 1-λ as we computed before,
-
plus 1-λ times δ 1, which we know to be 0,
-
and so, this is cancelled.
-
And the final output is λ times 1-λ.
-
At the next step, once again, the recursive equation kicks in,
-
and we have λ times the previous value,
-
which we know to be λ times 1- λ + 1-λ δ of 2,
-
but again, δ from now on is going to be zero,
-
so this term, we don't need to have to look at.
-
And so, here we have λ squared times 1-λ.
-
Next step is going to be the same.
-
And you have pretty much understood what's going on here.
-
If we plot the impulse response, we have an exponentially decaying function
-
where the exponential basis is λ, and the whole curve is weighted by 1-λ
-
and it's, of course multiplied by uni step (?) because everything is 0 for n less than 0.
-
You might wonder why we call this filter a Leaky Integrator.
-
The reason is, because if you consider, for instance, this very simple sum:
-
it's the sum of all input samples from minus infinity to current time.
-
This is really the discrete time approximation to an integral,
-
because you're really accumulating all past values up to now.
-
And we can rewrite this summation here as such.
-
So, at each step, we get what we have accumulated up to the previous step,
-
and we sum the current input.
-
So you see, it's very close to the equation for the Leaky Integrator.
-
Except that in the Leaky Integrator, what we do is the following.
-
We scale the previous accumulated value, by λ.
-
Which means, we -- remember λ is close to one,
-
so that means we keep pretty much all of what we have accumulated before,
-
but we "forget" a little bit.
-
We leak a part of it.
-
If λ is equal to 0.9,
-
then it means that 10% of what we have accumulated is lost.
-
And we replace what we've lost by a fraction of the input,
-
and this fraction is 1-λ.
-
So, what we've lost from the accumulator,
-
we'll replace with an equal percentage of the input.
-
The idea is that by picking λ less than one,
-
we are forgetting, we are leaking the past,
-
and the accumulation will never blow up.