Welcome back to
Practical Time Series Analysis. We've talked in our previous lectures
about the fundamental driving mechanisms that give rise to stochastic processes
that create the time series that you might be interested in analyzing. We've looked at moving average processes,
auto regressive processes, we've included trend,
we've included seasonality. We're going to take a bit of a different
approach in this lecture and begin to talk about forecasting. There are many methods here. We'll start with a very basic method,
Simple Exponential Smoothing, which does enjoy widespread
application in business and industry. It's something that people really do. We're going to try to make predictions
about the future or forecasts, let's say, based upon data that
we already have available to us. So you might be interested in predicting
sales figures for the upcoming holiday season based upon what you've
seen over the last several seasons. You might be interested in ridership
on a train, a railway system. There are all sorts of reasons people
have for looking at what's happening, or making good guesses about what's likely to
happen in the future based upon data that you already have available. In this particular lecture,
we'll use Simple Exponential Smoothing. And you'll be able to do this
with time series data that you find interesting to
make a simple forecast. As is often the case in these lectures,
an explicit goal is, you should be able to explain Simple Exponential Smoothing
to a friend or a colleague. What is it? How do you do it? What does it do for you? The data set that we'll be examining
here is on London rainfall, primarily in the 19th century, getting
into the 20th century a little bit. There's a nice discussion in
A Little Book of R for Time Series, and you can also access the original data. Rather than just using
a built-in data set from R, let's expand a little bit and
grab these data right off the Internet. R has a nice facility, the scan command,
that will allow you to go to a website, grab some data, and store it in an array. Once we have our numbers available to us,
we'll create a time series object to get a little bit
of structure and makes some calls. Now, if you've never thought
about rainfall in London before, then it's good to do even
the most vanilla things. Let's get a histogram
of our rainfall data. We'll take a look at the distribution. We'll almost reflexively take a look about
whether it's normally distributed or not. And close, not quite normally distributed. Looks like a systematic departure from
normality, but nothing too extreme. Looking at the times series as a sequence,
we look for the sorts of patterns we like to observe. If you feel that that's very difficult
to do just by looking at the sequence, pull up the auto correlation function and
take a look. As I'm looking at that data set,
I'm kind of seeing noise. I really can't make myself see much
of a structure in that data set. But maybe it's there, and
I'm just not seeing it. We'll call auto.arima to see if we can
see if we can get nice, fitted model. And even auto.arima says, no, sorry. The coefficients, the autoregressive
moving average coefficients, nothing. But we do get an average so
there is a model. It's just a very simple model. The model's just 24.8 So in light of this, we'll try to
do a little bit of forecasting. There are different notations
that people use here. And we'll look at one of the common
ones in this lecture, and we'll see another common
one in the next lecture. Where we'll let the subscript tell
us where we'd like the forecast. So h is how many periods into
the future you'd like to look. Maybe this is Tuesday and
you'd like to look for Next Tuesday. So h would be 7, if you have daily data. The superscript tells you what
data you're using when you're making your forecast,
data up through time step n. The most naive forecasting method I can
think of, is to say that what is going to happen tomorrow, our forecast for
tomorrow is just what was happening today. That's considered a naive method. In the notation that we've developed,
we would say x subscript n+1, there's the next period. Based upon data available at n is just
your observed value at time period n. Now, some data have a pretty
obvious seasonality to them. And we would say something like,
the forecast that we'll make for the next time period, n+1 based
upon data available up through and including time n is what was
happening one season ago. So if we're dealing with weeks,
capital S there would be a 7. Another way of thinking about
your forecasting is to say that we'll predict what's going to
happen in the next period is just an average of what's happened previously. Simple Exponential Smoothing
tries to do a little bit better than just a plain old average. It's going to develop
a weighting of previous values. So in our current data set,
we're going to try to predict the rainfall, the London rainfall in
a future period based upon the data. And we'll try to be aware of
updating on our data set. So instead of just taking an average and
including all of the data points equally, what we'll try to do is try to weight
the data points that are closer to us a little bit more and those that
are further away a little bit less. We're more formal in the reading. In the readings,
we'll deal with geometric series and see that we can weight our
averages through geometric series. We'll also show, and
this is not very deep, that rather than include the infinite
number of data points, what you can do is treat this as a weighted average of, we'll
say, for instance, you can see right here. We'll start with some data value, x sub 1. And we'll make a forecast for
x sub 2 just based upon x sub 1, we have a pretty meager amount of
information as we just get started. Then we will say, okay, so
if you would like to make a forecast for time period three based upon data
available in time period two, let's take our previous
smooth level value, our previous averaged value,
give that a weighting of 1-alpha. But we'll update it by looking at
the freshly available data point x sub 2. This is the common pattern. We'll take alpha times
your freshest data point + 1-alpha times your previous forecast. So if you'd like to make
a forecast about time period 4, you'll take alpha times your
new value at time 3 and add to it 1-alpha times your previous
level or your previous forecast. Some of us learn by writing code, and
that's what we'll try to do right now. It's rather simple,
we just need a fore loop. So in our little DIY, do it yourself code,
we'll let alpha = .2. And that's totally
unmotivated at this point. We'll see how to choose a good
alpha in just a moment. But we'll let alpha = .2. We'll create a vector forecast.values,
and we'll set it to NULL. We're just trying to establish
array that we can use in our loop. n, of course, is the length of the data
that you have available to you. Your first forecast is just
going to be your first data point. And now, we'll loop to get more forecasts. So we'll create forecast values as alpha
times your updated your freshly available data point, + (1-alpha) times your
previous forecast, your previous level. A little before formatting,
we'll use the past command so it looks nice on the screen when
we actually give our forecast. So for the year 1913,
based upon data available up through, including the year 1912,
the forecast value using the unmotivated, almost random alpha of 0.2
would be 25.3 inches of rain. But let's drill down on this a little. How could you choose alpha intelligently? How much weighting do you want to give
to values that are close at hand? And how much weighting do you want to
give to values that were further away? In this particular data set,
it looks like the best alpha, best in terms of making our sums of squares
errors or SSE as small as possible. Best alpha seems to be
really rather small. Back around, it's hard to read
off of this picture, and so I've blown it up here,
back around 0.024 or so. We use the SSE approach, so we'll make
a forecast for time period three. And then, we'll compare that to the actual
data point that we have available at time period three. Make a forecast at time period four, compare it to the actual data
point at time period four. In each time, we'll, of course,
take a different square and then add them up to get
an aggregate error. Now, such a common approach, of course,
people have written routines for you. HoltWinters, these are names that will become famous to even us as we
look into the next lectures. HoltWinters is a routine available in R,
and it implements the work of
these two mathematicians. This is from the years 1957,
58, 1960, there abouts. We'll grab the time series for rain. There are going to be three parameters
that we'll be keeping track of in the next couple of lectures. We'll deal with level,
trend, and seasonality. So this is a little
unmotivated at this point, but we'll turn the trend and
the seasonality flags to FALSE. And we'll just come up
with quick forecasts. We predicted, or we established,
a decent value alpha 0.024. And you can see here, a more sophisticated
routine is coming up with an alpha value really very close to that. So that's your smoothing parameter. You can make a prediction. You should do this. Take the code that we
developed a few screens ago. And instead of alpha is 0.2,
substitute this alpha value 0.02412151 and you should come up with the same
prediction that the routine does. So you should be able to come
up with the same forecasts for 1913 as the HoltWinters routine does. What we see in this picture is
the smoothed average in red. These are all of your
forecasts right here. And I've superimposed that over
the general time series plot. At this point, you should be able to use
Simple Exponential Smoothing to make a simple forecast. And you should be able to,
in broad strokes, explain Simple Exponential Smoothing
to a friend or to a colleague.