| Title: | Time Series Prediction with Integrated Tuning |
| Version: | 1.2.747 |
| Description: | Time series prediction is a critical task in data analysis, requiring not only the selection of appropriate models, but also suitable data preprocessing and tuning strategies. TSPredIT (Time Series Prediction with Integrated Tuning) is a framework that provides a seamless integration of data preprocessing, decomposition, model training, hyperparameter optimization, and evaluation. Unlike other frameworks, TSPredIT emphasizes the co-optimization of both preprocessing and modeling steps, improving predictive performance. It supports a variety of statistical and machine learning models, filtering techniques, outlier detection, data augmentation, and ensemble strategies. More information is available in Salles et al. <doi:10.1007/978-3-662-68014-8_2>. |
| License: | MIT + file LICENSE |
| URL: | https://cefet-rj-dal.github.io/tspredit/, https://github.com/cefet-rj-dal/tspredit |
| BugReports: | https://github.com/cefet-rj-dal/tspredit/issues |
| Encoding: | UTF-8 |
| RoxygenNote: | 7.3.3 |
| Depends: | R (≥ 4.1.0) |
| Imports: | stats, DescTools, e1071, elmNNRcpp, FNN, forecast, hht, KFAS, mFilter, nnet, randomForest, wavelets, dplyr, daltoolbox |
| NeedsCompilation: | no |
| Packaged: | 2025-10-26 22:57:06 UTC; gpca |
| Author: | Eduardo Ogasawara 
[aut, ths, cre],
Cristiane Gea [aut],
Diego Carvalho [ctb],
Diogo Santos [aut],
Eduardo Bezerra [ctb],
Esther Pacitti [ctb],
Fabio Porto [ctb],
Fernando Alexandrino [aut],
Rebecca Salles [aut],
Vitoria Birindiba [aut],
CEFET/RJ [cph] |
| Maintainer: | Eduardo Ogasawara <eogasawara@ieee.org> |
| Repository: | CRAN |
| Date/Publication: | 2025-10-27 06:10:09 UTC |
MSE
Description
Compute mean squared error (MSE) between actual and predicted values.
Usage
MSE.ts(actual, prediction)
Arguments
actual |
Numeric vector of observed values. |
prediction |
Numeric vector of predicted values. |
Details
MSE = mean((actual - prediction)^2).
Value
Numeric scalar with the MSE.
R2
Description
Compute coefficient of determination (R-squared).
Usage
R2.ts(actual, prediction)
Arguments
actual |
Numeric vector of observed values. |
prediction |
Numeric vector of predicted values. |
Value
Numeric scalar with R-squared.
Subset Extraction for Time Series Data
Description
Extracts a subset of a time series object based on specified rows and columns. The function allows for flexible indexing and subsetting of time series data.
Usage
## S3 method for class 'ts_data'
x[i, j, ...]
Arguments
x |
|
i |
row i |
j |
column j |
... |
optional arguments |
Value
A new ts_data object with preserved metadata and column names.
Examples
data(tsd)
data10 <- ts_data(tsd$y, 10)
ts_head(data10)
#single line
data10[12,]
#range of lines
data10[12:13,]
#single column
data10[,1]
#range of columns
data10[,1:2]
#range of rows and columns
data10[12:13,1:2]
#single line and a range of columns
data10[12,1:2]
#range of lines and a single column
data10[12:13,1]
#single observation
data10[12,1]
Adjust ts_data
Description
Convert a compatible dataset to a ts_data object by setting
column names, class, and the sw attribute consistently.
Usage
adjust_ts_data(data)
Arguments
data |
Matrix or data.frame to adjust. |
Value
An adjusted ts_data.
Fit Time Series Model
Description
Generic for fitting a time series model.
Descendants should implement do_fit.<class>.
Usage
do_fit(obj, x, y = NULL)
Arguments
obj |
Model object to be fitted. |
x |
Matrix or data.frame with input features. |
y |
Vector or matrix with target values. |
Value
A fitted object (same class as obj).
Predict Time Series Model
Description
Generic for predicting with a fitted time series model.
Descendants should implement do_predict.<class>.
Usage
do_predict(obj, x)
Arguments
obj |
Fitted model object. |
x |
Matrix or data.frame with input features to predict. |
Value
Numeric vector with predicted values.
Fertilizers (Regression)
Description
List of Brazilian fertilizer consumption series for N, P2O5, K2O. All series are numeric and ordered by time.
brazil_n: nitrogen consumption from 1961 to 2020.
brazil_p2o5: phosphate consumption from 1961 to 2020.
brazil_k2o: potash consumption from 1961 to 2020.
Usage
data(fertilizers)
Format
list of fertilizers' time series.
Source
This dataset was obtained from the MASS library.
References
International Fertilizer Association (IFA): https://www.fertilizer.org
Examples
# Load dataset and preview one of the series (nitrogen)
data(fertilizers)
head(fertilizers$brazil_n)
sMAPE
Description
Compute symmetric mean absolute percent error (sMAPE).
Usage
sMAPE.ts(actual, prediction)
Arguments
actual |
Numeric vector of observed values. |
prediction |
Numeric vector of predicted values. |
Details
sMAPE = mean( |a - p| / ((|a| + |p|)/2) ), excluding zero denominators.
Value
Numeric scalar with the sMAPE.
References
S. Makridakis and M. Hibon (2000). The M3-Competition: results, conclusions and implications. International Journal of Forecasting, 16(4).
Select Optimal Hyperparameters for Time Series Models
Description
Identifies the optimal hyperparameters by minimizing the error from a dataset of hyperparameters. The function selects the hyperparameter configuration that results in the lowest average error. It wraps the dplyr library.
Usage
## S3 method for class 'ts_tune'
select_hyper(obj, hyperparameters)
Arguments
obj |
a |
hyperparameters |
hyperparameters dataset |
Value
returns the optimized key number of hyperparameters
ARIMA
Description
Create a time series prediction object based on the AutoRegressive Integrated Moving Average (ARIMA) family.
This constructor sets up an S3 time series regressor that leverages the
forecast package to automatically select orders via auto.arima and
provide one-step and multi-step forecasts.
Usage
ts_arima()
Details
ARIMA models combine autoregressive (AR), differencing (I), and
moving average (MA) components to model temporal dependence in a univariate
time series. The fit() method uses forecast::auto.arima() to select
orders using information criteria, and predict() supports both a single
one-step-ahead over a horizon (rolling) and direct multi-step forecasting.
Assumptions include (after differencing) approximate stationarity and homoskedastic residuals. Always inspect residual diagnostics for adequacy.
Value
A ts_arima object (S3), which inherits from ts_reg.
References
G. E. P. Box, G. M. Jenkins, G. C. Reinsel, and G. M. Ljung (2015). Time Series Analysis: Forecasting and Control. Wiley.
R. J. Hyndman and Y. Khandakar (2008). Automatic time series forecasting: The forecast package for R. Journal of Statistical Software, 27(3), 1–22. doi:10.18637/jss.v027.i03
Examples
# Example: rolling-origin evaluation with multi-step prediction
# Load package and dataset
library(daltoolbox)
data(tsd)
# 1) Wrap the raw vector as `ts_data` without sliding windows
ts <- ts_data(tsd$y, 0)
ts_head(ts, 3)
# 2) Split into train/test using the last 5 observations as test
samp <- ts_sample(ts, test_size = 5)
io_train <- ts_projection(samp$train)
io_test <- ts_projection(samp$test)
# 3) Fit ARIMA via auto.arima
model <- ts_arima()
model <- fit(model, x = io_train$input, y = io_train$output)
# 4) Predict 5 steps ahead from the most recent observed point
prediction <- predict(model, x = io_test$input[1,], steps_ahead = 5)
prediction <- as.vector(prediction)
output <- as.vector(io_test$output)
# 5) Evaluate forecast accuracy
ev_test <- evaluate(model, output, prediction)
ev_test
Augmentation by Awareness
Description
Bias the augmentation to emphasize more recent points in each window (recency awareness), increasing their contribution to the augmented sample.
Usage
ts_aug_awareness(factor = 1)
Arguments
factor |
Numeric factor controlling the recency weighting. |
Value
A ts_aug_awareness object.
References
Q. Wen et al. (2021). Time Series Data Augmentation for Deep Learning: A Survey. IJCAI Workshop on Time Series.
Examples
# Recency-aware augmentation over sliding windows
# Load package and example dataset
library(daltoolbox)
data(tsd)
# Convert to 10-lag sliding windows and preview
xw <- ts_data(tsd$y, 10)
ts_head(xw)
# Apply awareness augmentation (bias toward recent rows)
augment <- ts_aug_awareness()
augment <- fit(augment, xw)
xa <- transform(augment, xw)
ts_head(xa)
Augmentation by Awareness Smooth
Description
Recency-aware augmentation that also progressively smooths noise before applying the weighting, producing cleaner augmented samples.
Usage
ts_aug_awaresmooth(factor = 1)
Arguments
factor |
Numeric factor controlling the recency weighting. |
Value
A ts_aug_awaresmooth object.
References
Q. Wen et al. (2021). Time Series Data Augmentation for Deep Learning: A Survey. IJCAI Workshop on Time Series.
Examples
# Recency-aware augmentation with progressive smoothing
# Load package and example dataset
library(daltoolbox)
data(tsd)
# Convert to 10-lag sliding windows and preview
xw <- ts_data(tsd$y, 10)
ts_head(xw)
# Apply awareness+smooth augmentation and inspect result
augment <- ts_aug_awaresmooth()
augment <- fit(augment, xw)
xa <- transform(augment, xw)
ts_head(xa)
Augmentation by Flip
Description
Time series augmentation by mirroring sliding-window observations around their mean to increase diversity and reduce overfitting.
Usage
ts_aug_flip()
Details
This transformation preserves the window mean while flipping the deviations, effectively generating a symmetric variant of the local pattern.
Value
A ts_aug_flip object.
References
Q. Wen et al. (2021). Time Series Data Augmentation for Deep Learning: A Survey. IJCAI Workshop on Time Series.
Examples
# Flip augmentation around the window mean
# Load package and example dataset
library(daltoolbox)
data(tsd)
# Convert to sliding windows and preview
xw <- ts_data(tsd$y, 10)
ts_head(xw)
# Apply flip augmentation and inspect augmented windows
augment <- ts_aug_flip()
augment <- fit(augment, xw)
xa <- transform(augment, xw)
ts_head(xa)
Augmentation by Jitter
Description
Time series augmentation by adding low-amplitude random noise to each point to increase robustness and reduce overfitting.
Usage
ts_aug_jitter()
Details
Noise scale is estimated from within-window deviations.
Value
A ts_aug_jitter object.
References
J. T. Um et al. (2017). Data augmentation of wearable sensor data for Parkinson’s disease monitoring using convolutional neural networks.
Q. Wen et al. (2021). Time Series Data Augmentation for Deep Learning: A Survey. IJCAI Workshop on Time Series.
Examples
# Jitter augmentation with noise estimated from windows
# Load package and example dataset
library(daltoolbox)
data(tsd)
# Convert to sliding windows and preview
xw <- ts_data(tsd$y, 10)
ts_head(xw)
# Apply jitter (adds small noise; keeps target column unchanged)
augment <- ts_aug_jitter()
augment <- fit(augment, xw)
xa <- transform(augment, xw)
ts_head(xa)
No Augmentation
Description
Identity augmentation that returns the original windows while preserving the augmentation interface and indices.
Usage
ts_aug_none()
Value
A ts_aug_none object.
Examples
# Identity augmentation (no changes to windows)
# Load package and example dataset
library(daltoolbox)
data(tsd)
# Convert to sliding windows and preview
xw <- ts_data(tsd$y, 10)
ts_head(xw)
# No augmentation; returns the same windows with indices preserved
augment <- ts_aug_none()
augment <- fit(augment, xw)
xa <- transform(augment, xw)
ts_head(xa)
Augmentation by Shrink
Description
Decrease within-window deviation magnitude by a scaling factor to generate lower-variance variants while preserving the mean.
Usage
ts_aug_shrink(scale_factor = 0.8)
Arguments
scale_factor |
Numeric factor used to scale deviations. |
Value
A ts_aug_shrink object.
References
Q. Wen et al. (2021). Time Series Data Augmentation for Deep Learning: A Survey. IJCAI Workshop on Time Series.
Examples
# Shrink augmentation reduces within-window deviations
# Load package and example dataset
library(daltoolbox)
data(tsd)
# Convert to sliding windows and preview
xw <- ts_data(tsd$y, 10)
ts_head(xw)
# Apply shrink augmentation and inspect augmented windows
augment <- ts_aug_shrink()
augment <- fit(augment, xw)
xa <- transform(augment, xw)
ts_head(xa)
Augmentation by Stretch
Description
Increase within-window deviation magnitude by a scaling factor to produce higher-variance variants.
Usage
ts_aug_stretch(scale_factor = 1.2)
Arguments
scale_factor |
Numeric factor used to scale deviations. |
Value
A ts_aug_stretch object.
References
Q. Wen et al. (2021). Time Series Data Augmentation for Deep Learning: A Survey. IJCAI Workshop on Time Series.
Examples
# Stretch augmentation increases within-window deviations
# Load package and example dataset
library(daltoolbox)
data(tsd)
# Convert to sliding windows and preview
xw <- ts_data(tsd$y, 10)
ts_head(xw)
# Apply stretch augmentation and inspect augmented windows
augment <- ts_aug_stretch()
augment <- fit(augment, xw)
xa <- transform(augment, xw)
ts_head(xa)
Augmentation by Wormhole
Description
Generate augmented windows by selectively replacing lag terms with older lagged values, creating plausible alternative trajectories.
Usage
ts_aug_wormhole()
Details
This combinatorial replacement preserves overall scale while introducing temporal permutations of lag content.
Value
A ts_aug_wormhole object.
References
Q. Wen et al. (2021). Time Series Data Augmentation for Deep Learning: A Survey. IJCAI Workshop on Time Series.
Examples
# Wormhole augmentation replaces some lags with older values
# Load package and example dataset
library(daltoolbox)
data(tsd)
# Convert to sliding windows and preview
xw <- ts_data(tsd$y, 10)
ts_head(xw)
# Apply wormhole augmentation and inspect augmented windows
augment <- ts_aug_wormhole()
augment <- fit(augment, xw)
xa <- transform(augment, xw)
ts_head(xa)
ts_data
Description
Construct a time series data object used throughout the DAL Toolbox.
Accepts either a vector (raw time series) or a matrix/data.frame already
organized in sliding windows. Internally, a ts_data is stored as a matrix
with sw lag columns named t{lag} (e.g., t9, t8, ..., t0). When sw is
zero or one, the series is stored as a single column (t0).
Usage
ts_data(y, sw = 1)
Arguments
y |
Numeric vector or matrix-like. Time series values or sliding windows. |
sw |
Integer. Sliding-window size (number of lag columns). |
Value
A ts_data object (matrix with attributes and column names).
Examples
# Example: building sliding windows
data(tsd)
head(tsd)
# 1) Single-column ts_data (no windows)
data <- ts_data(tsd$y)
ts_head(data)
# 2) 10-lag sliding windows (t9 ... t0)
data10 <- ts_data(tsd$y, 10)
ts_head(data10)
ELM
Description
Create a time series prediction object that uses Extreme Learning Machine (ELM) regression.
It wraps the elmNNRcpp package to train single-hidden-layer networks with
randomly initialized hidden weights and closed-form output weights.
Usage
ts_elm(preprocess = NA, input_size = NA, nhid = NA, actfun = "purelin")
Arguments
preprocess |
Normalization preprocessor (e.g., |
input_size |
Integer. Number of lagged inputs used by the model. |
nhid |
Integer. Hidden layer size. |
actfun |
Character. One of 'sig', 'radbas', 'tribas', 'relu', 'purelin'. |
Details
ELMs are efficient to train and can perform well with appropriate
hidden size and activation choice. Consider normalizing inputs and tuning
nhid and the activation function.
Value
A ts_elm object (S3) inheriting from ts_regsw.
References
G.-B. Huang, Q.-Y. Zhu, and C.-K. Siew (2006). Extreme Learning Machine: Theory and Applications. Neurocomputing, 70(1–3), 489–501.
Examples
# Example: ELM with sliding-window inputs
# Load package and toy dataset
library(daltoolbox)
data(tsd)
# Create sliding windows of length 10 (t9 ... t0)
ts <- ts_data(tsd$y, 10)
ts_head(ts, 3)
# Split last 5 rows as test set
samp <- ts_sample(ts, test_size = 5)
# Project to inputs (X) and outputs (y)
io_train <- ts_projection(samp$train)
io_test <- ts_projection(samp$test)
# Define ELM with global min-max normalization and fit
model <- ts_elm(ts_norm_gminmax(), input_size = 4, nhid = 3, actfun = "purelin")
model <- fit(model, x = io_train$input, y = io_train$output)
# Forecast 5 steps ahead starting from the last known window
prediction <- predict(model, x = io_test$input[1,], steps_ahead = 5)
prediction <- as.vector(prediction)
output <- as.vector(io_test$output)
# Evaluate forecast error on the test horizon
ev_test <- evaluate(model, output, prediction)
ev_test
Exponential Moving Average (EMA)
Description
Smooth a series by exponentially decaying weights that give more importance to recent observations.
Usage
ts_fil_ema(ema = 3)
Arguments
ema |
exponential moving average size |
Details
EMA is related to simple exponential smoothing; it reacts faster to level changes than a simple moving average while reducing noise.
Value
A ts_fil_ema object.
References
C. C. Holt (1957). Forecasting trends and seasonals by exponentially weighted moving averages. O.N.R. Research Memorandum.
Examples
# Exponential moving average smoothing on a noisy series
# Load package and example data
library(daltoolbox)
data(tsd)
# Inject an outlier to illustrate smoothing effect
tsd$y[9] <- 2 * tsd$y[9]
# Define EMA filter, fit and transform the series
filter <- ts_fil_ema(ema = 3)
filter <- fit(filter, tsd$y)
y <- transform(filter, tsd$y)
# Compare original vs smoothed series
plot_ts_pred(y = tsd$y, yadj = y)
EMD Filter
Description
Empirical Mode Decomposition (EMD) filter that decomposes a signal into intrinsic mode functions (IMFs) and reconstructs a smoothed component.
Usage
ts_fil_emd(noise = 0.1, trials = 5)
Arguments
noise |
noise |
trials |
trials |
Value
A ts_fil_emd object.
References
N. E. Huang et al. (1998). The Empirical Mode Decomposition and the Hilbert Spectrum for nonlinear and non-stationary time series analysis. Proceedings of the Royal Society A.
Examples
# EMD-based smoothing: remove first IMF as noise
# Load package and example data
library(daltoolbox)
data(tsd)
tsd$y[9] <- 2 * tsd$y[9] # inject an outlier
# Fit EMD filter and reconstruct without the first (noisiest) IMF
filter <- ts_fil_emd()
filter <- fit(filter, tsd$y)
y <- transform(filter, tsd$y)
# Compare original vs smoothed series
plot_ts_pred(y = tsd$y, yadj = y)
FFT Filter
Description
Frequency-domain smoothing using the Fast Fourier Transform (FFT) to attenuate high-frequency components.
Usage
ts_fil_fft()
Details
The implementation estimates a cutoff based on spectral statistics and reconstructs the series from dominant frequencies.
Value
A ts_fil_fft object.
References
J. W. Cooley and J. W. Tukey (1965). An algorithm for the machine calculation of complex Fourier series. Math. Comput.
Examples
# Frequency-domain smoothing via FFT cutoff
# Load package and example data
library(daltoolbox)
data(tsd)
tsd$y[9] <- 2 * tsd$y[9] # inject an outlier
# Fit FFT-based filter and reconstruct without high frequencies
filter <- ts_fil_fft()
filter <- fit(filter, tsd$y)
y <- transform(filter, tsd$y)
# Compare original vs frequency-smoothed series
plot_ts_pred(y = tsd$y, yadj = y)
Hodrick-Prescott Filter
Description
Decompose a series into trend and cyclical components using the Hodrick–Prescott (HP) filter and optionally blend with the original series.
This filter removes short-term fluctuations by penalizing changes in the growth rate of the trend component.
Usage
ts_fil_hp(lambda = 100, preserve = 0.9)
Arguments
lambda |
It is the smoothing parameter of the Hodrick-Prescott filter. Lambda = 100*(frequency)^2 Correspondence between frequency and lambda values annual => frequency = 1 // lambda = 100 quarterly => frequency = 4 // lambda = 1600 monthly => frequency = 12 // lambda = 14400 weekly => frequency = 52 // lambda = 270400 daily (7 days a week) => frequency = 365 // lambda = 13322500 daily (5 days a week) => frequency = 252 // lambda = 6812100 |
preserve |
value between 0 and 1. Balance the composition of observations and applied filter. Values close to 1 preserve original values. Values close to 0 adopts HP filter values. |
Details
The filter strength is governed by lambda = 100 * frequency^2.
Use preserve in (0, 1] to convex-combine the raw series and the HP trend.
Value
A ts_fil_hp object.
References
R. J. Hodrick and E. C. Prescott (1997). Postwar U.S. business cycles: An empirical investigation. Journal of Money, Credit and Banking, 29(1).
Examples
# time series with noise
library(daltoolbox)
data(tsd)
tsd$y[9] <- 2*tsd$y[9]
# filter
filter <- ts_fil_hp(lambda = 100*(26)^2) #frequency assumed to be 26
filter <- fit(filter, tsd$y)
y <- transform(filter, tsd$y)
# plot
plot_ts_pred(y=tsd$y, yadj=y)
Kalman Filter
Description
Estimate a latent trend via a state-space model using the
Kalman Filter (KF), wrapping the KFAS package.
Usage
ts_fil_kalman(H = 0.1, Q = 1)
Arguments
H |
variance or covariance matrix of the measurement noise. This noise pertains to the relationship between the true system state and actual observations. Measurement noise is added to the measurement equation to account for uncertainties or errors associated with real observations. The higher this value, the higher the level of uncertainty in the observations. |
Q |
variance or covariance matrix of the process noise. This noise follows a zero-mean Gaussian distribution. It is added to the equation to account for uncertainties or unmodeled disturbances in the state evolution. The higher this value, the greater the uncertainty in the state transition process. |
Value
A ts_fil_kalman object.
References
R. E. Kalman (1960). A new approach to linear filtering and prediction problems. Journal of Basic Engineering, 82(1), 35–45.
Examples
# State-space smoothing with Kalman Filter (KF)
# Load package and example data
library(daltoolbox)
data(tsd)
tsd$y[9] <- 2 * tsd$y[9] # inject an outlier
# Fit KF (H = obs noise, Q = process noise) and transform
filter <- ts_fil_kalman()
filter <- fit(filter, tsd$y)
y <- transform(filter, tsd$y)
# Plot original vs KF-smoothed series
plot_ts_pred(y = tsd$y, yadj = y)
LOWESS Smoothing
Description
Locally Weighted Scatterplot Smoothing (LOWESS) fits local regressions to capture the primary trend while reducing noise and spikes.
Usage
ts_fil_lowess(f = 0.2)
Arguments
f |
smoothing parameter. The larger this value, the smoother the series will be. This provides the proportion of points on the plot that influence the smoothing. |
Value
A ts_fil_lowess object.
References
W. S. Cleveland (1979). Robust locally weighted regression and smoothing scatterplots. Journal of the American Statistical Association.
Examples
# time series with noise
library(daltoolbox)
data(tsd)
tsd$y[9] <- 2*tsd$y[9]
# filter
filter <- ts_fil_lowess(f = 0.2)
filter <- fit(filter, tsd$y)
y <- transform(filter, tsd$y)
# plot
plot_ts_pred(y=tsd$y, yadj=y)
Moving Average (MA)
Description
Smooth out fluctuations and reduce noise by averaging over a fixed-size rolling window.
Usage
ts_fil_ma(ma = 3)
Arguments
ma |
moving average size |
Details
Larger windows produce smoother series but may lag turning points.
Value
A ts_fil_ma object.
Examples
# time series with noise
library(daltoolbox)
data(tsd)
tsd$y[9] <- 2*tsd$y[9]
# filter
filter <- ts_fil_ma(3)
filter <- fit(filter, tsd$y)
y <- transform(filter, tsd$y)
# plot
plot_ts_pred(y=tsd$y, yadj=y)
No Filter
Description
Identity filter that returns the original series unchanged.
Usage
ts_fil_none()
Value
A ts_fil_none object.
Examples
# Identity filter (returns original series)
# Load package and example series
library(daltoolbox)
data(tsd)
tsd$y[9] <- 2 * tsd$y[9] # inject an outlier for comparison
# Fit identity filter and transform (no change expected)
filter <- ts_fil_none()
filter <- fit(filter, tsd$y)
y <- transform(filter, tsd$y)
# Plot original vs (identical) filtered series
plot_ts_pred(y = tsd$y, yadj = y)
Quadratic Exponential Smoothing
Description
Double/triple exponential smoothing capturing level, trend, and optionally seasonality components.
Usage
ts_fil_qes(gamma = FALSE)
Arguments
gamma |
If TRUE, enables the gamma seasonality component. |
Value
A ts_fil_qes object.
References
P. R. Winters (1960). Forecasting sales by exponentially weighted moving averages. Management Science.
Examples
# time series with noise
library(daltoolbox)
data(tsd)
tsd$y[9] <- 2*tsd$y[9]
# filter
filter <- ts_fil_qes()
filter <- fit(filter, tsd$y)
y <- transform(filter, tsd$y)
# plot
plot_ts_pred(y=tsd$y, yadj=y)
Recursive Filter
Description
Apply recursive linear filtering (ARMA-style recursion) to a univariate series or each column of a multivariate series. Useful for smoothing and mitigating autocorrelation.
Usage
ts_fil_recursive(filter)
Arguments
filter |
smoothing parameter. The larger the value, the greater the smoothing. The smaller the value, the less smoothing, and the resulting series shape is more similar to the original series. |
Value
A ts_fil_recursive object.
Examples
# time series with noise
library(daltoolbox)
data(tsd)
tsd$y[9] <- 2*tsd$y[9]
# filter
filter <- ts_fil_recursive(filter = 0.05)
filter <- fit(filter, tsd$y)
y <- transform(filter, tsd$y)
# plot
plot_ts_pred(y=tsd$y, yadj=y)
Robust EMD Filter
Description
Ensemble/robust EMD-based denoising using CEEMD to separate noise-dominated IMFs and reconstruct the signal.
Usage
ts_fil_remd(noise = 0.1, trials = 5)
Arguments
noise |
noise |
trials |
trials |
Value
A ts_fil_remd object.
References
Z. Wu and N. E. Huang (2009). Ensemble Empirical Mode Decomposition: a noise-assisted data analysis method. Advances in Adaptive Data Analysis.
Examples
# time series with noise
library(daltoolbox)
data(tsd)
tsd$y[9] <- 2*tsd$y[9]
# filter
filter <- ts_fil_remd()
filter <- fit(filter, tsd$y)
y <- transform(filter, tsd$y)
# plot
plot_ts_pred(y=tsd$y, yadj=y)
Seasonal Adjustment
Description
Remove the seasonal component from a time series while preserving level and trend, using a state-space/BATS approach.
Usage
ts_fil_seas_adj(frequency = NULL)
Arguments
frequency |
Frequency of the time series. It is an optional parameter. It can be configured when the frequency of the time series is known. |
Value
A ts_fil_seas_adj object.
References
R. J. Hyndman and G. Athanasopoulos (2021). Forecasting: Principles and Practice (3rd ed). OTexts. (BATS/seasonal adjustment)
Examples
# Seasonal adjustment using BATS at known frequency
# Load package and example data
library(daltoolbox)
data(tsd)
tsd$y[9] <- 2 * tsd$y[9] # inject an outlier (illustrative)
# Fit seasonal adjustment (set frequency if known) and transform
filter <- ts_fil_seas_adj(frequency = 26)
filter <- fit(filter, tsd$y)
y <- transform(filter, tsd$y)
# Plot original vs seasonally adjusted series
plot_ts_pred(y = tsd$y, yadj = y)
Simple Exponential Smoothing
Description
Exponential smoothing focused on the level component, with optional extensions to trend/seasonality via Holt–Winters variants.
Usage
ts_fil_ses(gamma = FALSE)
Arguments
gamma |
If TRUE, enables the gamma seasonality component. |
Value
A ts_fil_ses object.
References
R. G. Brown (1959). Statistical Forecasting for Inventory Control.
Examples
# time series with noise
library(daltoolbox)
data(tsd)
tsd$y[9] <- 2*tsd$y[9]
# filter
filter <- ts_fil_ses()
filter <- fit(filter, tsd$y)
y <- transform(filter, tsd$y)
# plot
plot_ts_pred(y=tsd$y, yadj=y)
Time Series Smooth
Description
Remove or reduce randomness (noise) using a robust smoothing strategy that first mitigates outliers and then smooths residual variation.
Usage
ts_fil_smooth()
Value
A ts_fil_smooth object.
Examples
# Robust smoothing with iterative outlier mitigation
# Load package and example data
library(daltoolbox)
data(tsd)
tsd$y[9] <- 2 * tsd$y[9] # inject an outlier
# Fit smoother and transform to reduce spikes/noise
filter <- ts_fil_smooth()
filter <- fit(filter, tsd$y)
y <- transform(filter, tsd$y)
# Compare original vs smoothed series
plot_ts_pred(y = tsd$y, yadj = y)
Smoothing Splines
Description
Fit a cubic smoothing spline to a time series for smooth trend extraction with a tunable roughness penalty.
Usage
ts_fil_spline(spar = NULL)
Arguments
spar |
smoothing parameter. When spar is specified, the coefficient of the integral of the squared second derivative in the fitting criterion (penalized log-likelihood) is a monotone function of spar. |
Value
A ts_fil_spline object.
References
P. Craven and G. Wahba (1978). Smoothing noisy data with spline functions. Numerische Mathematik.
Examples
# Smoothing splines with adjustable roughness penalty
# Load package and example data
library(daltoolbox)
data(tsd)
tsd$y[9] <- 2 * tsd$y[9] # inject an outlier
# Fit spline smoother (spar controls smoothness) and transform
filter <- ts_fil_spline(spar = 0.5)
filter <- fit(filter, tsd$y)
y <- transform(filter, tsd$y)
# Compare original vs smoothed series
plot_ts_pred(y = tsd$y, yadj = y)
Wavelet Filter
Description
Denoise a series using discrete wavelet transforms and selected wavelet families.
Usage
ts_fil_wavelet(filter = "haar")
Arguments
filter |
Available wavelet filters: 'haar', 'd4', 'la8', 'bl14', 'c6'. |
Value
A ts_fil_wavelet object.
References
S. Mallat (1989). A Theory for Multiresolution Signal Decomposition: The Wavelet Representation. IEEE Transactions on Pattern Analysis and Machine Intelligence.
Examples
# Denoising with discrete wavelets (optionally selecting best filter)
# Load package and example data
library(daltoolbox)
data(tsd)
tsd$y[9] <- 2 * tsd$y[9] # inject an outlier
# Fit wavelet filter ("haar" by default; can pass a list to select best)
filter <- ts_fil_wavelet()
filter <- fit(filter, tsd$y)
y <- transform(filter, tsd$y)
# Compare original vs wavelet-denoised series
plot_ts_pred(y = tsd$y, yadj = y)
Winsorization of Time Series
Description
Apply Winsorization to limit extreme values by replacing them with nearer order statistics, reducing the influence of outliers.
Usage
ts_fil_winsor()
Value
A ts_fil_winsor object.
References
J. W. Tukey (1962). The future of data analysis. Annals of Mathematical Statistics. (Winsorization discussed in robust summaries.)
Examples
# Winsorization: cap extreme values to reduce outlier impact
# Load package and example data
library(daltoolbox)
data(tsd)
tsd$y[9] <- 2 * tsd$y[9] # inject an outlier
# Fit Winsor filter and transform series
filter <- ts_fil_winsor()
filter <- fit(filter, tsd$y)
y <- transform(filter, tsd$y)
# Plot original vs Winsorized series
plot_ts_pred(y = tsd$y, yadj = y)
Extract the First Observations from a ts_data Object
Description
Return the first n observations from a ts_data.
Usage
ts_head(x, n = 6L, ...)
Arguments
x |
|
n |
number of rows to return |
... |
optional arguments |
Value
The first n observations of a ts_data (as a matrix/data.frame).
Examples
data(tsd)
data10 <- ts_data(tsd$y, 10)
ts_head(data10)
Time Series Integrated Tune
Description
Integrated tuning over input sizes, preprocessing, augmentation, and model hyperparameters for time series.
Usage
ts_integtune(
input_size,
base_model,
folds = 10,
ranges = NULL,
preprocess = list(ts_norm_gminmax()),
augment = list(ts_aug_none())
)
Arguments
input_size |
Integer vector. Candidate input window sizes. |
base_model |
Base model object for tuning. |
folds |
Integer. Number of cross-validation folds. |
ranges |
Named list of hyperparameter ranges to explore. |
preprocess |
List of preprocessing objects to compare. |
augment |
List of augmentation objects to apply during training. |
Value
A ts_integtune object.
References
Salles, R., Pacitti, E., Bezerra, E., Marques, C., Pacheco, C., Oliveira, C., Porto, F., Ogasawara, E. (2023). TSPredIT: Integrated Tuning of Data Preprocessing and Time Series Prediction Models. Lecture Notes in Computer Science.
Examples
# Integrated search over input size, preprocessing and model hyperparameters
library(daltoolbox)
data(tsd)
# Build windows and split into train/test, then project to (X, y)
ts <- ts_data(tsd$y, 10)
samp <- ts_sample(ts, test_size = 5)
io_train <- ts_projection(samp$train)
io_test <- ts_projection(samp$test)
# Configure integrated tuning: ranges for input_size, ELM (nhid, actfun), and preprocessors
tune <- ts_integtune(
input_size = 3:5,
base_model = ts_elm(),
ranges = list(nhid = 1:5, actfun = c('purelin')),
preprocess = list(ts_norm_gminmax())
)
# Run search; augmentation (if provided) is applied during training internally
model <- fit(tune, x = io_train$input, y = io_train$output)
# Forecast and evaluate on the held-out window
prediction <- predict(model, x = io_test$input[1,], steps_ahead = 5)
prediction <- as.vector(prediction)
output <- as.vector(io_test$output)
ev_test <- evaluate(model, output, prediction)
ev_test
KNN Time Series Prediction
Description
Create a prediction object that uses the K-Nearest Neighbors regression for time series via sliding windows.
Usage
ts_knn(preprocess = NA, input_size = NA, k = NA)
Arguments
preprocess |
Normalization preprocessor (e.g., |
input_size |
Integer. Number of lagged inputs. |
k |
Integer. Number of neighbors. |
Details
KNN regression predicts a value as the average (or weighted average) of the outputs of the k most similar windows in the training set. Similarity is computed in the feature space induced by lagged inputs. Consider normalization for distance-based methods.
Value
A ts_knn object (S3) inheriting from ts_regsw.
References
T. M. Cover and P. E. Hart (1967). Nearest neighbor pattern classification. IEEE Transactions on Information Theory, 13(1), 21–27.
Examples
# Example: distance-based regression on sliding windows
# Load tools and example series
library(daltoolbox)
data(tsd)
# Build 10-lag windows and preview a few rows
ts <- ts_data(tsd$y, 10)
ts_head(ts, 3)
# Split end of series as test and project (X, y)
samp <- ts_sample(ts, test_size = 5)
io_train <- ts_projection(samp$train)
io_test <- ts_projection(samp$test)
# Define KNN regressor and fit (distance-based; normalization recommended)
model <- ts_knn(ts_norm_gminmax(), input_size = 4, k = 3)
model <- fit(model, x = io_train$input, y = io_train$output)
# Predict multiple steps ahead and evaluate
prediction <- predict(model, x = io_test$input[1,], steps_ahead = 5)
prediction <- as.vector(prediction)
output <- as.vector(io_test$output)
ev_test <- evaluate(model, output, prediction)
ev_test
MLP
Description
Create a time series prediction object based on a Multilayer Perceptron (MLP) regressor.
It wraps the nnet package to train a single-hidden-layer neural network
on sliding-window inputs. Use ts_regsw utilities to project inputs/outputs.
Usage
ts_mlp(preprocess = NA, input_size = NA, size = NA, decay = 0.01, maxit = 1000)
Arguments
preprocess |
Normalization preprocessor (e.g., |
input_size |
Integer. Number of lagged inputs used by the model. |
size |
Integer. Number of hidden neurons. |
decay |
Numeric. L2 weight decay (regularization) parameter. |
maxit |
Integer. Maximum number of training iterations. |
Details
The MLP is a universal function approximator capable of learning
non-linear mappings from lagged inputs to next-step values. For stability,
consider normalizing inputs (e.g., ts_norm_gminmax()). Hidden size and
weight decay control capacity and regularization respectively.
Value
A ts_mlp object (S3) inheriting from ts_regsw.
References
D. E. Rumelhart, G. E. Hinton, and R. J. Williams (1986). Learning representations by back-propagating errors. Nature 323, 533–536.
W. N. Venables and B. D. Ripley (2002). Modern Applied Statistics with S. Fourth Edition. Springer. (for the
nnetpackage)
Examples
# Example: MLP on sliding windows with min–max normalization
# Load package and dataset
library(daltoolbox)
data(tsd)
ts <- ts_data(tsd$y, 10)
ts_head(ts, 3)
samp <- ts_sample(ts, test_size = 5)
io_train <- ts_projection(samp$train)
io_test <- ts_projection(samp$test)
# Prepare projection (X, y)
samp <- ts_sample(ts, test_size = 5)
io_train <- ts_projection(samp$train)
io_test <- ts_projection(samp$test)
# Define and fit the MLP
model <- ts_mlp(ts_norm_gminmax(), input_size = 4, size = 4, decay = 0)
model <- fit(model, x=io_train$input, y=io_train$output)
# Predict 5 steps ahead
prediction <- predict(model, x = io_test$input[1,], steps_ahead = 5)
prediction <- as.vector(prediction)
output <- as.vector(io_test$output)
# Evaluate
ev_test <- evaluate(model, output, prediction)
ev_test
Adaptive Normalization
Description
Transform data to a common scale while adapting to changes in distribution over time (optionally over a trailing window).
Usage
ts_norm_an(outliers = outliers_boxplot(), nw = 0)
Arguments
outliers |
Indicate outliers transformation class. NULL can avoid outliers removal. |
nw |
integer: window size. |
Value
A ts_norm_an object.
References
Ogasawara, E., Martinez, L. C., De Oliveira, D., Zimbrão, G., Pappa, G. L., Mattoso, M. (2010). Adaptive Normalization: A novel data normalization approach for non-stationary time series. Proceedings of the International Joint Conference on Neural Networks (IJCNN). doi:10.1109/IJCNN.2010.5596746
Examples
# time series to normalize
library(daltoolbox)
data(tsd)
# convert to sliding windows
ts <- ts_data(tsd$y, 10)
ts_head(ts, 3)
summary(ts[,10])
# normalization
preproc <- ts_norm_an()
preproc <- fit(preproc, ts)
tst <- transform(preproc, ts)
ts_head(tst, 3)
summary(tst[,10])
First Differences
Description
Transform a series by first differences to remove level and highlight changes; normalization is then applied to the differenced series.
Usage
ts_norm_diff(outliers = outliers_boxplot())
Arguments
outliers |
Indicate outliers transformation class. NULL can avoid outliers removal. |
Value
A ts_norm_diff object.
References
Salles, R., Assis, L., Guedes, G., Bezerra, E., Porto, F., Ogasawara, E. (2017). A framework for benchmarking machine learning methods using linear models for univariate time series prediction. Proceedings of the International Joint Conference on Neural Networks (IJCNN). doi:10.1109/IJCNN.2017.7966139
Examples
# Differencing + global min–max normalization
# Load package and example data
library(daltoolbox)
data(tsd)
# Convert to sliding windows and preview raw last column
ts <- ts_data(tsd$y, 10)
ts_head(ts, 3)
summary(ts[,10])
# Fit differencing preprocessor and transform; note one fewer lag column
preproc <- ts_norm_diff()
preproc <- fit(preproc, ts)
tst <- transform(preproc, ts)
ts_head(tst, 3)
summary(tst[,9])
Adaptive Normalization with EMA
Description
Normalize a time series using exponentially weighted statistics that adapt to distributional changes, optionally after outlier mitigation.
Usage
ts_norm_ean(outliers = outliers_boxplot(), nw = 0)
Arguments
outliers |
Indicate outliers transformation class. NULL can avoid outliers removal. |
nw |
windows size |
Value
A ts_norm_ean object.
References
Ogasawara, E., Martinez, L. C., De Oliveira, D., Zimbrão, G., Pappa, G. L., Mattoso, M. (2010). Adaptive Normalization: A novel data normalization approach for non-stationary time series. Proceedings of the International Joint Conference on Neural Networks (IJCNN). doi:10.1109/IJCNN.2010.5596746
Examples
# time series to normalize
library(daltoolbox)
data(tsd)
# convert to sliding windows
ts <- ts_data(tsd$y, 10)
ts_head(ts, 3)
summary(ts[,10])
# normalization
preproc <- ts_norm_ean()
preproc <- fit(preproc, ts)
tst <- transform(preproc, ts)
ts_head(tst, 3)
summary(tst[,10])
Global Min–Max Normalization
Description
Rescale values so the global minimum maps to 0 and the global maximum maps to 1 over the training set.
Usage
ts_norm_gminmax(outliers = outliers_boxplot())
Arguments
outliers |
Indicate outliers transformation class. NULL can avoid outliers removal. |
Details
The same scaling is applied to inputs and inverted on predictions
via inverse_transform.
Value
A ts_norm_gminmax object.
References
Ogasawara, E., Murta, L., Zimbrão, G., Mattoso, M. (2009). Neural networks cartridges for data mining on time series. Proceedings of the International Joint Conference on Neural Networks (IJCNN). doi:10.1109/IJCNN.2009.5178615
Examples
# Global min–max normalization across the full training set
# Load package and example data
library(daltoolbox)
data(tsd)
# Build 10-lag windows and preview raw scale
ts <- ts_data(tsd$y, 10)
ts_head(ts, 3)
summary(ts[,10])
# Fit global min–max and transform; inspect post-scale values
preproc <- ts_norm_gminmax()
preproc <- fit(preproc, ts)
tst <- transform(preproc, ts)
ts_head(tst, 3)
summary(tst[,10])
No Normalization
Description
Identity transform that leaves data unchanged but aligns with the pre/post-processing interface.
Usage
ts_norm_none()
Value
A ts_norm_none object.
Examples
# Identity normalization (no scaling applied)
# Load package and example data
library(daltoolbox)
data(tsd)
# Convert to sliding windows
xw <- ts_data(tsd$y, 10)
# No data normalization — transform returns inputs unchanged
normalize <- ts_norm_none()
normalize <- fit(normalize, xw)
xa <- transform(normalize, xw)
ts_head(xa)
Sliding-Window Min–Max Normalization
Description
Create an object for normalizing each window by its own min and max, preserving local contrast while standardizing scales.
Usage
ts_norm_swminmax(outliers = outliers_boxplot())
Arguments
outliers |
Indicate outliers transformation class. NULL can avoid outliers removal. |
Value
A ts_norm_swminmax object.
References
Ogasawara, E., Murta, L., Zimbrão, G., Mattoso, M. (2009). Neural networks cartridges for data mining on time series. Proceedings of the International Joint Conference on Neural Networks (IJCNN). doi:10.1109/IJCNN.2009.5178615
Examples
# Per-window min–max normalization for sliding windows
# Load package and example data
library(daltoolbox)
data(tsd)
# Build 10-lag windows and preview raw scale
ts <- ts_data(tsd$y, 10)
ts_head(ts, 3)
summary(ts[,10])
# Fit per-window min–max and transform; inspect post-scale values
preproc <- ts_norm_swminmax()
preproc <- fit(preproc, ts)
tst <- transform(preproc, ts)
ts_head(tst, 3)
summary(tst[,10])
Time Series Projection
Description
Split a ts_data (sliding windows) into input features and
output targets for modeling.
Usage
ts_projection(ts)
Arguments
ts |
Matrix or data.frame containing a |
Details
For a multi-column ts_data, returns all but the last column as
inputs and the last column as the output. For a single-row matrix, returns
ts_data-wrapped inputs/outputs preserving names and window size.
Value
A ts_projection object with two elements: $input and $output.
Examples
# Setting up a ts_data and projecting (X, y)
# Load example dataset and create windows
data(tsd)
ts <- ts_data(tsd$y, 10)
io <- ts_projection(ts)
# Input data (features)
ts_head(io$input)
# Output data (target)
ts_head(io$output)
TSReg
Description
Base class for time series regression models that operate directly on time series (non-sliding-window specialization).
Usage
ts_reg()
Details
This class is intended to be subclassed by modeling backends that
do not require the sliding-window interface. Methods such as fit(),
predict(), and evaluate() dispatch on this class.
Value
A ts_reg object (S3) to be extended by concrete models.
Examples
# Abstract base class — instantiate concrete subclasses instead
# Examples: ts_mlp(), ts_rf(), ts_svm(), ts_arima()
TSRegSW
Description
Base class for time series regression models built on sliding-window representations.
Usage
ts_regsw(preprocess = NA, input_size = NA)
Arguments
preprocess |
Normalization preprocessor (e.g., |
input_size |
Integer. Number of lagged inputs per example. |
Details
This class provides helpers to map ts_data matrices into the
input window expected by ML backends and to apply pre/post processing
(e.g., normalization) consistently during fit and predict.
Value
A ts_regsw object (S3) to be extended by concrete models.
Examples
# Abstract base class for sliding-window regressors
# Use concrete subclasses such as ts_mlp(), ts_rf(), ts_svm(), ts_elm()
Random Forest
Description
Create a time series prediction object that uses Random Forest regression on sliding-window inputs.
It wraps the randomForest package to fit an ensemble of decision trees.
Usage
ts_rf(preprocess = NA, input_size = NA, nodesize = 1, ntree = 10, mtry = NULL)
Arguments
preprocess |
Normalization preprocessor (e.g., |
input_size |
Integer. Number of lagged inputs used by the model. |
nodesize |
Integer. Minimum terminal node size. |
ntree |
Integer. Number of trees in the forest. |
mtry |
Integer. Number of variables randomly sampled at each split. |
Details
Random Forests reduce variance by averaging many decorrelated trees.
For tabular sliding-window features, they can capture nonlinearities and
interactions without heavy feature engineering. Consider normalizing inputs
for comparability across windows and tuning mtry, ntree, and nodesize.
Value
A ts_rf object (S3) inheriting from ts_regsw.
References
L. Breiman (2001). Random forests. Machine Learning, 45(1), 5–32.
Examples
# Example: sliding-window Random Forest
# Load tools and data
library(daltoolbox)
data(tsd)
# Turn series into 10-lag windows and preview
ts <- ts_data(tsd$y, 10)
ts_head(ts, 3)
# Train/test split and (X, y) projection
samp <- ts_sample(ts, test_size = 5)
io_train <- ts_projection(samp$train)
io_test <- ts_projection(samp$test)
# Define Random Forest and fit (tune ntree/mtry/nodesize as needed)
model <- ts_rf(ts_norm_gminmax(), input_size = 4, nodesize = 3, ntree = 50)
model <- fit(model, x = io_train$input, y = io_train$output)
# Forecast multiple steps and assess error
prediction <- predict(model, x = io_test$input[1,], steps_ahead = 5)
prediction <- as.vector(prediction)
output <- as.vector(io_test$output)
ev_test <- evaluate(model, output, prediction)
ev_test
Time Series Sample
Description
Split a ts_data into train and test sets.
Extracts test_size rows from the end (minus an optional offset) as the
test set. The remaining initial rows form the training set. The offset
is useful to reproduce experiments with different forecast origins.
Usage
ts_sample(ts, test_size = 1, offset = 0)
Arguments
ts |
A |
test_size |
Integer. Number of rows in the test split (default = 1). |
offset |
Integer. Offset from the end before the test split (default = 0). |
Value
A list with $train and $test (both ts_data).
Examples
# Setting up a ts_data and making a temporal split
# Load example dataset and build windows
data(tsd)
ts <- ts_data(tsd$y, 10)
# Separating into train and test
test_size <- 3
samp <- ts_sample(ts, test_size)
# First five rows from training data
ts_head(samp$train, 5)
# Last five rows from training data
ts_head(samp$train[-c(1:(nrow(samp$train)-5)),])
# Testing data
ts_head(samp$test)
SVM
Description
Create a time series prediction object that uses Support Vector Regression (SVR) on sliding-window inputs.
It wraps the e1071 package to fit epsilon-insensitive regression with
linear, radial, polynomial, or sigmoid kernels.
Usage
ts_svm(
preprocess = NA,
input_size = NA,
kernel = "radial",
epsilon = 0,
cost = 10
)
Arguments
preprocess |
Normalization preprocessor (e.g., |
input_size |
Integer. Number of lagged inputs used by the model. |
kernel |
Character. One of 'linear', 'radial', 'polynomial', 'sigmoid'. |
epsilon |
Numeric. Epsilon-insensitive loss width. |
cost |
Numeric. Regularization parameter controlling margin violations. |
Details
SVR aims to find a function with at most epsilon deviation from
each training point while being as flat as possible. The cost parameter
controls the trade-off between margin width and violations; epsilon
controls the insensitivity tube width. RBF kernels often work well for
nonlinear series; tune cost, epsilon, and kernel hyperparameters.
Value
A ts_svm object (S3) inheriting from ts_regsw.
References
C. Cortes and V. Vapnik (1995). Support-Vector Networks. Machine Learning, 20, 273–297.
Examples
# Example: SVR with min–max normalization
# Load package and dataset
library(daltoolbox)
data(tsd)
# Create sliding windows and preview
ts <- ts_data(tsd$y, 10)
ts_head(ts, 3)
# Temporal split and (X, y) projection
samp <- ts_sample(ts, test_size = 5)
io_train <- ts_projection(samp$train)
io_test <- ts_projection(samp$test)
# Define SVM regressor and fit to training data
model <- ts_svm(ts_norm_gminmax(), input_size = 4)
model <- fit(model, x = io_train$input, y = io_train$output)
# Multi-step forecast and evaluation
prediction <- predict(model, x = io_test$input[1,], steps_ahead = 5)
prediction <- as.vector(prediction)
output <- as.vector(io_test$output)
ev_test <- evaluate(model, output, prediction)
ev_test
Time Series Tune
Description
Create a ts_tune object for hyperparameter tuning of a
time series model.
Sets up a cross-validated search over hyperparameter ranges and input sizes for a base model. Results include the evaluated configurations and the selected best configuration.
Usage
ts_tune(input_size, base_model, folds = 10, ranges = NULL)
Arguments
input_size |
Integer vector. Candidate input window sizes. |
base_model |
Base model object to tune (e.g., |
folds |
Integer. Number of cross-validation folds. |
ranges |
Named list of hyperparameter ranges to explore. |
Value
A ts_tune object.
References
R. Kohavi (1995). A study of cross-validation and bootstrap for accuracy estimation and model selection. IJCAI.
Salles, R., Pacitti, E., Bezerra, E., Marques, C., Pacheco, C., Oliveira, C., Porto, F., Ogasawara, E. (2023). TSPredIT: Integrated Tuning of Data Preprocessing and Time Series Prediction Models. Lecture Notes in Computer Science.
Examples
# Example: grid search over input_size and ELM hyperparameters
# Load library and example data
library(daltoolbox)
data(tsd)
# Prepare 10-lag windows and split into train/test
ts <- ts_data(tsd$y, 10)
ts_head(ts, 3)
samp <- ts_sample(ts, test_size = 5)
io_train <- ts_projection(samp$train)
io_test <- ts_projection(samp$test)
# Define tuning: vary input_size and ELM hyperparameters (nhid, actfun)
tune <- ts_tune(
input_size = 3:5,
base_model = ts_elm(ts_norm_gminmax()),
ranges = list(nhid = 1:5, actfun = c('purelin'))
)
# Run CV-based search and get the best fitted model
model <- fit(tune, x = io_train$input, y = io_train$output)
# Forecast and evaluate on the held-out horizon
prediction <- predict(model, x = io_test$input[1,], steps_ahead = 5)
prediction <- as.vector(prediction)
output <- as.vector(io_test$output)
ev_test <- evaluate(model, output, prediction)
ev_test
Time series example dataset
Description
Synthetic dataset based on a sine function.
x: correspond time from 0 to 10.
y: dependent variable for time series modeling.
Usage
data(tsd)
Format
data.frame.
Source
This dataset was generated for examples.
Examples
# Load dataset and preview the first rows
data(tsd)
head(tsd)