Nothing
utsf"
In utsf: Univariate Time Series Forecasting
knitr::opts_chunk$set(
collapse = TRUE,
comment = "#>"
)
library(utsf)
In this document the utsf package is described. This package offers a meta engine for applying different regression models for univariate time series forecasting using an autoregressive approach.
Univariate time series forecasting and autoregressive models
An univariate time series forecasting method is one in which the future values of a series are predicted using only information from the series. For example, the future values of a series can be forecast by its mean historical value. An advantage of this type of prediction is that, apart from the series being forecast, there is no need to collect any further information in order to train the model used to predict the future values of the series.
An autoregressive model is a kind of univariate time series forecasting model in which a value of a time series is expressed as a function of some of its past values. That is, an autoregressive model is a regression model in which the independent variables are lagged values (previous values) of the response variable. For example, given a time series with the following historical values: $t = {1, 3, 6, 7, 9, 11, 16}$, suppose that we want to develop an autoregressive model in which a target "is explained" by its first, second and fourth past values (in this context, a previous value is also called a lag, so lag 1 is the value immediately preceding a given value in the series). Given this series and lags (1, 2 and 4), the training set would be:
| Lag 4 | Lag 2 | Lag 1 | Target |
|-------|-------|-------|--------|
| 1 | 6 | 7 | 9 |
| 3 | 7 | 9 | 11 |
| 6 | 9 | 11 | 16 |
In this model the next future value of the series is predicted as $f(Lag4, Lag2, Lag1)$, where $f$ is the regression function and $Lag4$, $Lag2$ and $Lag1$ are the fourth, second and first lagged values of the next future value. So, the next future value of series $t$ is predicted as $f(7, 11, 16)$, producing a value that will be called $F1$.
Suppose that the forecast horizon (the number of future values to be forecast into the future) is greater than 1. In the case that the regression function only predicts the next future value of the series, a recursive approach can be applied to forecast all the future values of the forecast horizon. Using a recursive approach, the regression function is applied recursively until all horizons are forecast. For instance, following the previous example, suppose that the forecast horizon is 3. As we have explained, to forecast the next future value of the series (horizon 1) the regression function is fed with the vector $[7, 11, 16]$, producing $F1$. To forecast horizon 2 the regression function is fed with the vector $[9, 16, F1]$. The forecast for horizon 1, $F1$, is used as the first lag for horizon 2 because the actual value is unknown. Finally, to predict horizon 3 the regression function is fed with the vector [$11, F1, F2]$. This example of recursive forecast is summarized in the following table:
|Horizon | Autoregressive values | Forecast |
|--------|-----------------------|----------|
| 1 | 7, 11, 16 | F1 |
| 2 | 9, 16, F1 | F2 |
| 3 | 11, F1, F2 | F3 |
The recursive approach for forecasting several values into the future is applied in classical statistical models such as ARIMA or exponential smoothing.
The utsf package
The utsf package makes it easy the use of classical regression models for univariate time series forecasting employing the autoregressive approach and the recursive prediction strategy explained in the previous section. All the supported models are applied using an uniform interface: the forecast() function. Let us see an example in which a regression tree model is used to forecast the next future values of a time series:
f <- forecast(AirPassengers, h = 12, lags = 1:12, method = "rt")
In this example, an autoregressive tree model (method = "rt") is trained using the historical values of the AirPassengers time series and a forecast for its 12 next future values (h = 12) is done. The forecast() function returns an S3 object of class utsf with information about the trained model and the forecast. The information about the forecast is included in the component pred as an object of class ts (a time series):
f$pred
library(ggplot2)
autoplot(f)
The training set used to fit the model is built from the historical values of the time series using the autoregressive approach explained in the previous section. The lags parameter of the forecast() function is used to specify the autoregressive lags. In the example: lags = 1:12, so a target is a function of its 12 previous values. Next, we consult the first targets (and their associated features) with which the regression model has been trained:
head(f$targets) # first targets
head(f$features) # and its associated features
Using the example of the previous section:
t <- ts(c(1, 3, 6, 7, 9, 11, 16))
out <- forecast(t, h = 3, lags = c(1, 2, 4), preProcess = list(trend("none")))
cbind(out$features, Target = out$targets)
Supported models
The forecast() function provides a common interface to applying an autoregressive approach for time series forecasting using different regression models. These models are implemented in several R packages. Currently, the forecast() function is mainly focused on regression tree models, supporting the following approaches:
- k-nearest neighbors: In this case no model is trained and the function
FNN::knn.reg() is used, as regression function, to recursively predict the future values of the time series.
- Linear models: The model is trained using the function
stats::lm() and its associated method
stats::predict.lm() is applied recursively for the forecasts, i.e., as regression function.
- Regression trees: The model is trained using the function
rpart::rpart() and its associated method rpart::predict.rpart() is used for the forecasts.
- Model trees: The model is trained with the function
Cubist::cubist() and its associated method Cubist::predict.cubist() is used for predictions.
- Bagging: The model is trained with the function
ipred::bagging() and its
associated method ipred::predict.regbagg() is used for forecasting.
- Random forest: The model is trained with the function
ranger::ranger() and its associated method ranger::predict.ranger() is used for predictions.
The S3 object of class utsf returned by the forecast() function contains a component with the trained autoregressive model:
f <- forecast(fdeaths, h = 12, lags = 1:12, method = "rt")
f$model
In this case, the model is the result of training a regression tree using the function rpart::rpart() with the training set consisting of the features f$features and targets f$targets. Once the model is trained, the rpart::predict.rpart() function is used recursively to forecast the future values of the time series.
Using your own models
An interesting feature of the utsf package is that you can use the forecast() function to apply your own regression models for time series forecasting in an autoregressive way. Thus, your regression models can benefit from the features implemented in the forecast() function, such as preprocessing, parameter tuning, the building of the training set, the implementation of recursive forecasts or the estimation of the forecast accuracy of the model.
To apply your own regression model with the forecast() function you have to use the method parameter, providing a function that is able to train your model. This function should return an object with the trained regression model. Also, it must have at least two input parameters:
X: it is a data frame with the features of the training examples. This data frame is built from the time series taking into account the autoregressive lags as explained in a previous section. This is the same object as the features component of the object returned by the forecast() function.y: a vector with the targets of the training examples. It is built as explained in a previous section. It is the same object as the targets component of the object returned by the forecast() function.
Furthermore, if the function that trains the model (the function provided in the method parameter) returns a model of class model_class, a method with the signature predict.model_class(object, new_value) should be implemented. This method uses your model to predict a new value, that is, it is the regression function associated with the model.
Let us see an example in which the forecast() function is used to forecast a time series using the k-nearest neighbors regression model implemented in the package FNN:
# Function to train the regression model
my_knn_model <- function(X, y, k = 3) {
structure(list(X = X, y = y, k = k), class = "my_knn")
}
# Function to predict a new example
predict.my_knn <- function(object, new_value) {
FNN::knn.reg(train = object$X, test = new_value,
y = object$y, k = object$k)$pred
}
f <- forecast(AirPassengers, h = 12, lags = 1:12, method = my_knn_model)
f$pred
autoplot(f)
The new_value parameter of the predict method receives a data frame with the same structure as the X parameter of the function for building the model. The new_value data frame has only one row, with the features of the example to be predicted.
The k-nearest neighbors algorithm is so simple that it can be easily implemented without using functionality from any R package:
# Function to train the regression model
my_knn_model2 <- function(X, y, k = 3) {
structure(list(X = X, y = y, k = k), class = "my_knn2")
}
# Function to predict a new example
predict.my_knn2 <- function(object, new_value) {
distances <- sapply(1:nrow(object$X), function(i) sum((object$X[i, ] - new_value)^2))
k_nearest <- order(distances)[1:object$k]
mean(object$y[k_nearest])
}
f2 <- forecast(AirPassengers, h = 12, lags = 1:12, method = my_knn_model2)
f2$pred
Setting the parameters of the regression models
Normally, a regression model can be adjusted using different parameters. By default, the models supported by the forecast() function are set using some specific parameters, usually the default values of the functions used to train the models (these functions are listed in a previous section). However, the user can set the parameters used to train the regression models with the param argument of the forecast() function. The param argument must be a list with the names and values of the parameters to be set. Let us see an example:
# A bagging model set with default parameters
f <- forecast(AirPassengers, h = 12, lags = 1:12, method = "bagging")
length(f$model$mtrees) # number of regression trees (25 by default)
# A bagging model set with 3 regression tress
f <- forecast(AirPassengers, h = 12,
lags = 1:12,
method = "bagging",
param = list(nbagg = 3)
)
length(f$model$mtrees) # number of regression trees
In the previous example, two bagging models (using regression trees) are trained with the forecast() function. In the first model the number of trees is 25, the default value of the function ipred::ipredbagg() used to train the model. In the second model the number of trees is set to 3. Of course, in order to set some specific parameters the user must consult the arguments of the function used internally by the forecast() function to train the model. In the example, ipred::ipredbagg().
In the following example the user sets the parameters of a regression model implemented by himself/herself:
# Function to train the model
my_knn_model <- function(X, y, k = 3) {
structure(list(X = X, y = y, k = k), class = "my_knn")
}
# Regression function for object of class my_knn
predict.my_knn <- function(object, new_value) {
FNN::knn.reg(train = object$X, test = new_value,
y = object$y, k = object$k)$pred
}
# The model is trained with default parameters (k = 3)
f <- forecast(AirPassengers, h = 12, lags = 1:12, method = my_knn_model)
print(f$model$k)
# The model is trained with k = 5
f <- forecast(AirPassengers, h = 12,
method = my_knn_model, param = list(k = 5))
print(f$model$k)
Estimating forecast accuracy
This section explains how to estimate the forecast accuracy of a regression model predicting a time series with the utsf package. Let us see an example:
f <- forecast(UKgas, h = 4, lags = 1:4, method = "knn", efa = evaluation("normal", size = 8))
f$global_efa
To assess the forecast accuracy of a regression model you can use the forecast() function to specify the regression task, using the efa parameter to choose how the forecast accuracy is estimated. In this case, a k-nearest neighbors model is used (model = "knn") with the autoregressive lags 1 to 4 and an estimation of its forecast accuracy on the UKgas time series for a forecast horizon of 4 (h = 4) is obtained using a fixed origin strategy. The result of this estimation can be found in the global_efa component of the object returned by the forecast() function. It is a vector with estimates of forecast errors according to different forecast accuracy measures. For instance, in the example, the estimated mean absolute error (MAE) for horizon 4 is 43.1 approximately. Currently, the following forecasting accuracy measures are computed:
- MAE: mean absolute error
- MAPE: mean absolute percentage error
- sMAPE: symmetric MAPE
- RMSE: root mean squared error
Next, we describe how the forecasting accuracy measures are computed for a forecasting horizon $h$ ($y_t$ and $\hat{y}_t$ are the actual future value and its forecast for horizon $t$ respectively):
$$
MAE = \frac{1}{h}\sum_{t=1}^{h} |y_t-\hat{y}_t|
$$
$$
MAPE = \frac{1}{h}\sum_{t=1}^{h} 100\frac{|y_t-\hat{y}t|}{y_t}
$$
$$
sMAPE = \frac{1}{h}\sum{t=1}^{h} 200\frac{\left|y_{t}-\hat{y}_{t}\right|}{|y_t|+|\hat{y}_t|}
$$
$$
RMSE = \sqrt{\frac{1}{h}\sum_{t=1}^{h} (y_t-\hat{y}_t)^2}
$$
The efa parameter is created with the evaluation() function. The estimation of forecast accuracy is done with rolling origin evaluation. The last observations of the time series are used as test set using the rolling origin technique. The number of observations conforming the test set can be specified as follows:
evaluation("normal", size = 10) # The last 10 observations are used as test set
evaluation("normal", prop = 0.2) # The last 20% part of the series is used as test set
It is also estimated the forecast accuracy per forecasting horizon:
f$efa_per_horizon
Parameter tuning
Another useful feature of the utsf package is parameter tuning. The forecast() function allows you to estimate the forecast accuracy of a model using different combinations of parameters. Furthermore, the best combination of parameters is used to train a model with all the historical values of the series and the model is applied for forecasting the future values of the series. Let us see an example:
f <- forecast(UKgas, h = 4, lags = 1:4, method = "knn",
tuneGrid = expand.grid(k = 1:7), efa = evaluation("normal", size = 4))
f$tuneGrid
In this example, the tuneGrid parameter is used to specify (using a data frame) the set of parameters to assess. The forecast accuracy of the model for the different combinations of parameters is estimated as explained in the previous section using the last observations of the time series as validation set. The efa parameter is used to specify the size of the test set. The tuneGrid component of the object returned by the forecast() function contains the result of the estimation. In this case, the k-nearest neighbors method using $k=1$ obtains the best results for all the forecast accuracy measures. The best combination of parameters according to RMSE is used to forecast the time series:
f$param
f$pred
Let us plot the values of $k$ against their estimated accuracy using RMSE:
plot(f$tuneGrid$k, f$tuneGrid$RMSE, type = "o", pch = 19, xlab = "k (number of nearest neighbors)", ylab = "RMSE", main = "Estimated accuracy")
Preprocessings and transformations
Sometimes, the forecast accuracy of a model can be improved by applying some transformations and/or preprocessings to the time series being forecast. Currently, the utsf package is focused on preprocessings related to forecasting time series with a trend. This is due to the fact that, at present, the models incorporated in the forecast() function (such as regression trees and k-nearest neighbors) predict averages of the targets in the training set (i.e., an average of historical values of the series). In a trended series these averages are probably outside the range of the future values of the series. Let us see an example in which a trended series (the yearly revenue passenger miles flown by commercial airlines in the United States) is forecast using a random forest model:
f <- forecast(airmiles, h = 4, lags = 1:4, method = "rf", preProcess = list(trend("none")))
autoplot(f)
In this case, no preprocessing is applied (preProcess = list(trend("none"))). It can be observed how the forecast does not capture the trending behavior of the series because regression tree models predict averaged values of the training targets.
In the next subsections we explain how to deal with trended series using three different transformations.
Differencing
A common way of dealing with trended series is to transform the original series taking first differences (computing the differences between consecutive observations). Then, the model is trained with the differenced series and the forecasts are back-transformed. Let us see an example:
f <- forecast(airmiles, h = 4, lags = 1:4, method = "rf", preProcess = list(trend("differences", 1)))
autoplot(f)
In this case, the preProcess parameter has been used to specify first-order differences. The preProcess parameter consists of a list of preprocessings or transformations. Currently, only one preprocessing can be specified. The order of first differences is specified with the second parameter of the trend() function (normally 1). It is also possible to specify the value -1, in which case the order of differences is estimated using the ndiffs() function from the forecast package (in that case the chosen order of first differences could be 0, that is, no differences are applied).
# The order of first differences is estimated using the ndiffs function
f <- forecast(airmiles, h = 4, lags = 1:4, method = "rf", preProcess = list(trend("differences", -1)))
f$differences
The additive transformation
This transformation has been used to deal with trending series in other packages, such as tsknn and tsfgrnn. The additive transformation works transforming the training examples as follows:
- A vector of features is transformed by subtracting the mean of the vector.
- The target associated with a vector of features is transformed by subtracting from it the mean of its associated vector of features.
- To back transform a prediction, the mean of the input vector is added to it.
It is easy to check how the training examples are modified by the additive transformation using the API of the package. For example, let us see the training examples of a model with no transformation:
timeS <- ts(c(1, 3, 7, 9, 10, 12))
f <- forecast(timeS, h = 1, lags = 1:2, preProcess = list(trend("none")))
cbind(f$features, Targets = f$targets)
Now, let us see the effect of the additive transformation in the training examples:
timeS <- ts(c(1, 3, 7, 9, 10, 12))
f <- forecast(timeS, h = 1, lags = 1:2, preProcess = list(trend("additive")))
cbind(f$features, Targets = f$targets)
Finally, we forecast the airmiles series using the additive transformation and a random forest model:
f <- forecast(airmiles, h = 4, lags = 1:4, method = "rf")
autoplot(f)
In this last code snippet we have used the default value of preProcess, because it applies the additive transformation.
The multiplicative transformation
The multiplicative transformation is similar to the additive transformation, but it is intended for series with an exponential trend (the additive transformation is suited for series with a linear trend). In the multiplicative transformation a training example is transformed this way:
- A vector of features is transformed by dividing it by its mean.
- The target associated with a vector of features is transformed by dividing it by the mean of its associated vector of features.
- To back transform a prediction, the prediction is multiplied by the mean of the input vector.
Let us see an example of an artificial time series with a multiplicative trend and its forecast using the additive and the multiplicative transformation:
t <- ts(10 * 1.05^(1:20))
f_m <- forecast(t, h = 4, lags = 1:3, method = "rf", preProcess = list(trend("multiplicative")))
f_a <- forecast(t, h = 4, lags = 1:3, method = "rf", preProcess = list(trend("additive")))
library(vctsfr)
plot_predictions(t, predictions = list(Multiplicative = f_m$pred, Additive = f_a$pred))
In this case, the forecast with the multiplicative transformation captures perfectly the exponential trend.
Default parameters
The forecast() function only has two compulsory parameters: the time series being forecast and the forecast horizon. Next, we discuss the default values for the rest of its parameters:
lags: The lags parameter is an integer vector (in increasing order) with the autoregressive lags. If frequency(ts) == f where ts is the time series being forecast and $f > 1$ then the lags used as autoregressive features are 1:f. For example, the lags for quarterly data are 1:4 and for monthly data 1:12. This is useful to capture a possible seasonal behavior of the series. If frequency(ts) == 1, then:
- The lags with significant autocorrelation in the partial autocorrelation function (
stats::pacf()) are selected.
- If no lag has a significant autocorrelation, then lags 1:5 are chosen.
- If only one lag has significant autocorrelation and the additive or multiplicative transformation is applied, then lags 1:5 are chosen. This is done because it does not make sense to use these transformations with only one autoregressive lag.
method: By default, the k-nearest neighbors algorithm is applied.param: By default, the model is trained using some sensible parameters, normally the default values of the function used to train the model.preProcess: The additive transformation is applied. This transformation have proved its effectiveness to forecast trending series. In general, its application seems beneficial on any kind of series.efa: No estimation of forecast accuracy is done.tuneGrid: No estimation of forecast accuracy is done.
Try the utsf package in your browser
Any scripts or data that you put into this service are public.
utsf documentation built on June 8, 2025, 10:44 a.m.
R Package Documentation
Browse R Packages
We want your feedback!
Note that we can't provide technical support on individual packages. You should contact the package authors for that.
knitr::opts_chunk$set( collapse = TRUE, comment = "#>" )
library(utsf)
In this document the utsf package is described. This package offers a meta engine for applying different regression models for univariate time series forecasting using an autoregressive approach.
Univariate time series forecasting and autoregressive models
An univariate time series forecasting method is one in which the future values of a series are predicted using only information from the series. For example, the future values of a series can be forecast by its mean historical value. An advantage of this type of prediction is that, apart from the series being forecast, there is no need to collect any further information in order to train the model used to predict the future values of the series.
An autoregressive model is a kind of univariate time series forecasting model in which a value of a time series is expressed as a function of some of its past values. That is, an autoregressive model is a regression model in which the independent variables are lagged values (previous values) of the response variable. For example, given a time series with the following historical values: $t = {1, 3, 6, 7, 9, 11, 16}$, suppose that we want to develop an autoregressive model in which a target "is explained" by its first, second and fourth past values (in this context, a previous value is also called a lag, so lag 1 is the value immediately preceding a given value in the series). Given this series and lags (1, 2 and 4), the training set would be:
| Lag 4 | Lag 2 | Lag 1 | Target | |-------|-------|-------|--------| | 1 | 6 | 7 | 9 | | 3 | 7 | 9 | 11 | | 6 | 9 | 11 | 16 |
In this model the next future value of the series is predicted as $f(Lag4, Lag2, Lag1)$, where $f$ is the regression function and $Lag4$, $Lag2$ and $Lag1$ are the fourth, second and first lagged values of the next future value. So, the next future value of series $t$ is predicted as $f(7, 11, 16)$, producing a value that will be called $F1$.
Suppose that the forecast horizon (the number of future values to be forecast into the future) is greater than 1. In the case that the regression function only predicts the next future value of the series, a recursive approach can be applied to forecast all the future values of the forecast horizon. Using a recursive approach, the regression function is applied recursively until all horizons are forecast. For instance, following the previous example, suppose that the forecast horizon is 3. As we have explained, to forecast the next future value of the series (horizon 1) the regression function is fed with the vector $[7, 11, 16]$, producing $F1$. To forecast horizon 2 the regression function is fed with the vector $[9, 16, F1]$. The forecast for horizon 1, $F1$, is used as the first lag for horizon 2 because the actual value is unknown. Finally, to predict horizon 3 the regression function is fed with the vector [$11, F1, F2]$. This example of recursive forecast is summarized in the following table:
|Horizon | Autoregressive values | Forecast | |--------|-----------------------|----------| | 1 | 7, 11, 16 | F1 | | 2 | 9, 16, F1 | F2 | | 3 | 11, F1, F2 | F3 |
The recursive approach for forecasting several values into the future is applied in classical statistical models such as ARIMA or exponential smoothing.
The utsf package
The utsf package makes it easy the use of classical regression models for univariate time series forecasting employing the autoregressive approach and the recursive prediction strategy explained in the previous section. All the supported models are applied using an uniform interface: the forecast() function. Let us see an example in which a regression tree model is used to forecast the next future values of a time series:
f <- forecast(AirPassengers, h = 12, lags = 1:12, method = "rt")
In this example, an autoregressive tree model (method = "rt") is trained using the historical values of the AirPassengers time series and a forecast for its 12 next future values (h = 12) is done. The forecast() function returns an S3 object of class utsf with information about the trained model and the forecast. The information about the forecast is included in the component pred as an object of class ts (a time series):
f$pred library(ggplot2) autoplot(f)
The training set used to fit the model is built from the historical values of the time series using the autoregressive approach explained in the previous section. The lags parameter of the forecast() function is used to specify the autoregressive lags. In the example: lags = 1:12, so a target is a function of its 12 previous values. Next, we consult the first targets (and their associated features) with which the regression model has been trained:
head(f$targets) # first targets head(f$features) # and its associated features
Using the example of the previous section:
t <- ts(c(1, 3, 6, 7, 9, 11, 16)) out <- forecast(t, h = 3, lags = c(1, 2, 4), preProcess = list(trend("none"))) cbind(out$features, Target = out$targets)
Supported models
The forecast() function provides a common interface to applying an autoregressive approach for time series forecasting using different regression models. These models are implemented in several R packages. Currently, the forecast() function is mainly focused on regression tree models, supporting the following approaches:
- k-nearest neighbors: In this case no model is trained and the function
FNN::knn.reg()is used, as regression function, to recursively predict the future values of the time series. - Linear models: The model is trained using the function
stats::lm()and its associated methodstats::predict.lm()is applied recursively for the forecasts, i.e., as regression function. - Regression trees: The model is trained using the function
rpart::rpart()and its associated methodrpart::predict.rpart()is used for the forecasts. - Model trees: The model is trained with the function
Cubist::cubist()and its associated methodCubist::predict.cubist()is used for predictions. - Bagging: The model is trained with the function
ipred::bagging()and its associated methodipred::predict.regbagg()is used for forecasting. - Random forest: The model is trained with the function
ranger::ranger()and its associated methodranger::predict.ranger()is used for predictions.
The S3 object of class utsf returned by the forecast() function contains a component with the trained autoregressive model:
f <- forecast(fdeaths, h = 12, lags = 1:12, method = "rt") f$model
In this case, the model is the result of training a regression tree using the function rpart::rpart() with the training set consisting of the features f$features and targets f$targets. Once the model is trained, the rpart::predict.rpart() function is used recursively to forecast the future values of the time series.
Using your own models
An interesting feature of the utsf package is that you can use the forecast() function to apply your own regression models for time series forecasting in an autoregressive way. Thus, your regression models can benefit from the features implemented in the forecast() function, such as preprocessing, parameter tuning, the building of the training set, the implementation of recursive forecasts or the estimation of the forecast accuracy of the model.
To apply your own regression model with the forecast() function you have to use the method parameter, providing a function that is able to train your model. This function should return an object with the trained regression model. Also, it must have at least two input parameters:
X: it is a data frame with the features of the training examples. This data frame is built from the time series taking into account the autoregressive lags as explained in a previous section. This is the same object as thefeaturescomponent of the object returned by theforecast()function.y: a vector with the targets of the training examples. It is built as explained in a previous section. It is the same object as thetargetscomponent of the object returned by theforecast()function.
Furthermore, if the function that trains the model (the function provided in the method parameter) returns a model of class model_class, a method with the signature predict.model_class(object, new_value) should be implemented. This method uses your model to predict a new value, that is, it is the regression function associated with the model.
Let us see an example in which the forecast() function is used to forecast a time series using the k-nearest neighbors regression model implemented in the package FNN:
# Function to train the regression model my_knn_model <- function(X, y, k = 3) { structure(list(X = X, y = y, k = k), class = "my_knn") } # Function to predict a new example predict.my_knn <- function(object, new_value) { FNN::knn.reg(train = object$X, test = new_value, y = object$y, k = object$k)$pred } f <- forecast(AirPassengers, h = 12, lags = 1:12, method = my_knn_model) f$pred autoplot(f)
The new_value parameter of the predict method receives a data frame with the same structure as the X parameter of the function for building the model. The new_value data frame has only one row, with the features of the example to be predicted.
The k-nearest neighbors algorithm is so simple that it can be easily implemented without using functionality from any R package:
# Function to train the regression model my_knn_model2 <- function(X, y, k = 3) { structure(list(X = X, y = y, k = k), class = "my_knn2") } # Function to predict a new example predict.my_knn2 <- function(object, new_value) { distances <- sapply(1:nrow(object$X), function(i) sum((object$X[i, ] - new_value)^2)) k_nearest <- order(distances)[1:object$k] mean(object$y[k_nearest]) } f2 <- forecast(AirPassengers, h = 12, lags = 1:12, method = my_knn_model2) f2$pred
Setting the parameters of the regression models
Normally, a regression model can be adjusted using different parameters. By default, the models supported by the forecast() function are set using some specific parameters, usually the default values of the functions used to train the models (these functions are listed in a previous section). However, the user can set the parameters used to train the regression models with the param argument of the forecast() function. The param argument must be a list with the names and values of the parameters to be set. Let us see an example:
# A bagging model set with default parameters f <- forecast(AirPassengers, h = 12, lags = 1:12, method = "bagging") length(f$model$mtrees) # number of regression trees (25 by default) # A bagging model set with 3 regression tress f <- forecast(AirPassengers, h = 12, lags = 1:12, method = "bagging", param = list(nbagg = 3) ) length(f$model$mtrees) # number of regression trees
In the previous example, two bagging models (using regression trees) are trained with the forecast() function. In the first model the number of trees is 25, the default value of the function ipred::ipredbagg() used to train the model. In the second model the number of trees is set to 3. Of course, in order to set some specific parameters the user must consult the arguments of the function used internally by the forecast() function to train the model. In the example, ipred::ipredbagg().
In the following example the user sets the parameters of a regression model implemented by himself/herself:
# Function to train the model my_knn_model <- function(X, y, k = 3) { structure(list(X = X, y = y, k = k), class = "my_knn") } # Regression function for object of class my_knn predict.my_knn <- function(object, new_value) { FNN::knn.reg(train = object$X, test = new_value, y = object$y, k = object$k)$pred } # The model is trained with default parameters (k = 3) f <- forecast(AirPassengers, h = 12, lags = 1:12, method = my_knn_model) print(f$model$k) # The model is trained with k = 5 f <- forecast(AirPassengers, h = 12, method = my_knn_model, param = list(k = 5)) print(f$model$k)
Estimating forecast accuracy
This section explains how to estimate the forecast accuracy of a regression model predicting a time series with the utsf package. Let us see an example:
f <- forecast(UKgas, h = 4, lags = 1:4, method = "knn", efa = evaluation("normal", size = 8)) f$global_efa
To assess the forecast accuracy of a regression model you can use the forecast() function to specify the regression task, using the efa parameter to choose how the forecast accuracy is estimated. In this case, a k-nearest neighbors model is used (model = "knn") with the autoregressive lags 1 to 4 and an estimation of its forecast accuracy on the UKgas time series for a forecast horizon of 4 (h = 4) is obtained using a fixed origin strategy. The result of this estimation can be found in the global_efa component of the object returned by the forecast() function. It is a vector with estimates of forecast errors according to different forecast accuracy measures. For instance, in the example, the estimated mean absolute error (MAE) for horizon 4 is 43.1 approximately. Currently, the following forecasting accuracy measures are computed:
- MAE: mean absolute error
- MAPE: mean absolute percentage error
- sMAPE: symmetric MAPE
- RMSE: root mean squared error
Next, we describe how the forecasting accuracy measures are computed for a forecasting horizon $h$ ($y_t$ and $\hat{y}_t$ are the actual future value and its forecast for horizon $t$ respectively):
$$ MAE = \frac{1}{h}\sum_{t=1}^{h} |y_t-\hat{y}_t| $$
$$ MAPE = \frac{1}{h}\sum_{t=1}^{h} 100\frac{|y_t-\hat{y}t|}{y_t} $$ $$ sMAPE = \frac{1}{h}\sum{t=1}^{h} 200\frac{\left|y_{t}-\hat{y}_{t}\right|}{|y_t|+|\hat{y}_t|} $$
$$ RMSE = \sqrt{\frac{1}{h}\sum_{t=1}^{h} (y_t-\hat{y}_t)^2} $$
The efa parameter is created with the evaluation() function. The estimation of forecast accuracy is done with rolling origin evaluation. The last observations of the time series are used as test set using the rolling origin technique. The number of observations conforming the test set can be specified as follows:
evaluation("normal", size = 10) # The last 10 observations are used as test set evaluation("normal", prop = 0.2) # The last 20% part of the series is used as test set
It is also estimated the forecast accuracy per forecasting horizon:
f$efa_per_horizon
Parameter tuning
Another useful feature of the utsf package is parameter tuning. The forecast() function allows you to estimate the forecast accuracy of a model using different combinations of parameters. Furthermore, the best combination of parameters is used to train a model with all the historical values of the series and the model is applied for forecasting the future values of the series. Let us see an example:
f <- forecast(UKgas, h = 4, lags = 1:4, method = "knn", tuneGrid = expand.grid(k = 1:7), efa = evaluation("normal", size = 4)) f$tuneGrid
In this example, the tuneGrid parameter is used to specify (using a data frame) the set of parameters to assess. The forecast accuracy of the model for the different combinations of parameters is estimated as explained in the previous section using the last observations of the time series as validation set. The efa parameter is used to specify the size of the test set. The tuneGrid component of the object returned by the forecast() function contains the result of the estimation. In this case, the k-nearest neighbors method using $k=1$ obtains the best results for all the forecast accuracy measures. The best combination of parameters according to RMSE is used to forecast the time series:
f$param f$pred
Let us plot the values of $k$ against their estimated accuracy using RMSE:
plot(f$tuneGrid$k, f$tuneGrid$RMSE, type = "o", pch = 19, xlab = "k (number of nearest neighbors)", ylab = "RMSE", main = "Estimated accuracy")
Preprocessings and transformations
Sometimes, the forecast accuracy of a model can be improved by applying some transformations and/or preprocessings to the time series being forecast. Currently, the utsf package is focused on preprocessings related to forecasting time series with a trend. This is due to the fact that, at present, the models incorporated in the forecast() function (such as regression trees and k-nearest neighbors) predict averages of the targets in the training set (i.e., an average of historical values of the series). In a trended series these averages are probably outside the range of the future values of the series. Let us see an example in which a trended series (the yearly revenue passenger miles flown by commercial airlines in the United States) is forecast using a random forest model:
f <- forecast(airmiles, h = 4, lags = 1:4, method = "rf", preProcess = list(trend("none"))) autoplot(f)
In this case, no preprocessing is applied (preProcess = list(trend("none"))). It can be observed how the forecast does not capture the trending behavior of the series because regression tree models predict averaged values of the training targets.
In the next subsections we explain how to deal with trended series using three different transformations.
Differencing
A common way of dealing with trended series is to transform the original series taking first differences (computing the differences between consecutive observations). Then, the model is trained with the differenced series and the forecasts are back-transformed. Let us see an example:
f <- forecast(airmiles, h = 4, lags = 1:4, method = "rf", preProcess = list(trend("differences", 1))) autoplot(f)
In this case, the preProcess parameter has been used to specify first-order differences. The preProcess parameter consists of a list of preprocessings or transformations. Currently, only one preprocessing can be specified. The order of first differences is specified with the second parameter of the trend() function (normally 1). It is also possible to specify the value -1, in which case the order of differences is estimated using the ndiffs() function from the forecast package (in that case the chosen order of first differences could be 0, that is, no differences are applied).
# The order of first differences is estimated using the ndiffs function f <- forecast(airmiles, h = 4, lags = 1:4, method = "rf", preProcess = list(trend("differences", -1))) f$differences
The additive transformation
This transformation has been used to deal with trending series in other packages, such as tsknn and tsfgrnn. The additive transformation works transforming the training examples as follows:
- A vector of features is transformed by subtracting the mean of the vector.
- The target associated with a vector of features is transformed by subtracting from it the mean of its associated vector of features.
- To back transform a prediction, the mean of the input vector is added to it.
It is easy to check how the training examples are modified by the additive transformation using the API of the package. For example, let us see the training examples of a model with no transformation:
timeS <- ts(c(1, 3, 7, 9, 10, 12)) f <- forecast(timeS, h = 1, lags = 1:2, preProcess = list(trend("none"))) cbind(f$features, Targets = f$targets)
Now, let us see the effect of the additive transformation in the training examples:
timeS <- ts(c(1, 3, 7, 9, 10, 12)) f <- forecast(timeS, h = 1, lags = 1:2, preProcess = list(trend("additive"))) cbind(f$features, Targets = f$targets)
Finally, we forecast the airmiles series using the additive transformation and a random forest model:
f <- forecast(airmiles, h = 4, lags = 1:4, method = "rf") autoplot(f)
In this last code snippet we have used the default value of preProcess, because it applies the additive transformation.
The multiplicative transformation
The multiplicative transformation is similar to the additive transformation, but it is intended for series with an exponential trend (the additive transformation is suited for series with a linear trend). In the multiplicative transformation a training example is transformed this way:
- A vector of features is transformed by dividing it by its mean.
- The target associated with a vector of features is transformed by dividing it by the mean of its associated vector of features.
- To back transform a prediction, the prediction is multiplied by the mean of the input vector.
Let us see an example of an artificial time series with a multiplicative trend and its forecast using the additive and the multiplicative transformation:
t <- ts(10 * 1.05^(1:20)) f_m <- forecast(t, h = 4, lags = 1:3, method = "rf", preProcess = list(trend("multiplicative"))) f_a <- forecast(t, h = 4, lags = 1:3, method = "rf", preProcess = list(trend("additive"))) library(vctsfr) plot_predictions(t, predictions = list(Multiplicative = f_m$pred, Additive = f_a$pred))
In this case, the forecast with the multiplicative transformation captures perfectly the exponential trend.
Default parameters
The forecast() function only has two compulsory parameters: the time series being forecast and the forecast horizon. Next, we discuss the default values for the rest of its parameters:
lags: Thelagsparameter is an integer vector (in increasing order) with the autoregressive lags. Iffrequency(ts) == fwheretsis the time series being forecast and $f > 1$ then the lags used as autoregressive features are 1:f. For example, the lags for quarterly data are 1:4 and for monthly data 1:12. This is useful to capture a possible seasonal behavior of the series. Iffrequency(ts) == 1, then:- The lags with significant autocorrelation in the partial autocorrelation function (
stats::pacf()) are selected. - If no lag has a significant autocorrelation, then lags 1:5 are chosen.
- If only one lag has significant autocorrelation and the additive or multiplicative transformation is applied, then lags 1:5 are chosen. This is done because it does not make sense to use these transformations with only one autoregressive lag.
- The lags with significant autocorrelation in the partial autocorrelation function (
method: By default, the k-nearest neighbors algorithm is applied.param: By default, the model is trained using some sensible parameters, normally the default values of the function used to train the model.preProcess: The additive transformation is applied. This transformation have proved its effectiveness to forecast trending series. In general, its application seems beneficial on any kind of series.efa: No estimation of forecast accuracy is done.tuneGrid: No estimation of forecast accuracy is done.
Try the utsf package in your browser
Any scripts or data that you put into this service are public.
R Package Documentation
Browse R Packages
We want your feedback!
Note that we can't provide technical support on individual packages. You should contact the package authors for that.
Embedding an R snippet on your website
Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.