config-i1 / mes

Mixed Exponential Smoothing

mes

MES stands for "Mixed Exponential Smoothing". The package implements the model that encompasses the classical ETS and allows dealing with data with multiple frequencies (including the fractional ones), using explanatory variables and working with intermittent data - all in one flexible framework.

mes's Issues

Develop a method to smooth states of the model

This should lead to smoother seasonals and smoother level / trend. This should be a separate method, applied by a user, returning smooth ADAM (reconstructed model).

In order to see the issue run the following:
test <- adam(forecast::taylor,"MNM",lags=c(48,336),h=336,holdout=T,initial="b",silent=F)

auto.adam

The function that selects the most appropriate distribution.
Potential functionality - combination of models.

• For future work - ARMA selection, issues #13 and #21

Advanced loss functions

Implement the parameter loss with all the multiple steps ahead losses for mes().

The distribution parameter will be potentially detachable from the losses.

Create testthat scripts for ADAM

This should test:

1. ETS;
2. ARIMA;
3. Regression;
4. All their combinations;
5. Basic methods;
6. Different loss and distribution values;
7. forecast() with different interval types.

AR/MA lags in the ETS model

Add an option of specifying AR and MA in the model, making model even more complicated...

Treating different classes of data

Make mes work well with different classes and return similar ones. This applies to:

1. vector,
2. ts,
3. msts
4. xts,
5. data.table,
6. tsibble
7. ???

Tune the optimiser

Normalise all the parameter before the nloptr(), then denormalise them in the loop. See if this improves the speed of calculation and accuracy.

Speed up adam with ARIMA

This involves:

1. Code tuning and optimisation: make sure that there are no duplicates, check C++;
2. Memory usage: remove redundant variables.
3. Profiling - see, where the slowest parts are.

Introduce lags parameter in the mes() function

This should allow specifying several frequencies.
Do the integer frequencies first.

Combination based on pointLik

Use the idea of Nikos in order to create different pools and combine.

Fix the stability condition

Fix the stability condition, making independent eigenvalues for each unique lag, based on this: https://openforecast.org/adam/ADAMETSPureAdditive.html#stability-and-forecastability-conditions

This implies fixing:

1. CF
2. confint()

Develop simulation functions

The stuff that needs to be done:

1. sim.oes()
2. sim.oesg()
3. sim.mes(), combining sim.es() and sim.oes() / sim.oesg()

ARIMA orders selection in adam

Develop a mechanism of order selection inside the function. Should be something similar to auto.msarima... but maybe smarter, considering several special cases?

Add variables AR and MA for the parameters of the ARIMA components

This should either be explicit o provided in ellipsis.

Probably something like ARMA=list(AR=...,MA=...)

ARIMA and ARIMA orders selection on small samples

Develop a mechanism that would allow constructing at least something if the sample is small. Make adam() and auto.adam() robust.

Make level accept vector

This is relevant to forecast.adam() and predict.adam() functions. Make them return matrices in $lower and $upper if several levels are provided.

De-bias smoothing parameters in occurrence models

This comes to having higher than needed alphas / beta / gamma in ETS(A,Z,Z) and ETS(M,Z,Z) for different occurrence models.

xreg for factors

If a user provides a factor, then expand it and make one and the same smoothing parameter for all levels of it. This way, if we provide factor for week of year, we would have a mechanism similar to the proper seasonal component.

predict() and forecast() methods

These will partially depend on simulator functions and should be applicable for mes() and omes()

Develop the basic ETS model with normal distribution

This means the implementation similar to Hyndman et al. (2008)

1. Initialiser of the ETS model;
2. Fitter of the ETS model;
3. Estimator;
4. Likelihood extractor;
5. Conditional variance method;
6. vcov() method;
7. summary() in the alm() style;

Keep in mind the future lags variable and flexible structure of mes()

Deal with parametric prediction interval

1. Rename "approximate" to "parametric";
2. Develop / update the code for pure multiplicative models;
3. Fix stuff for ARIMA;
4. Deal with mixed models.

Rewrite the seasonal part of the model

An example. When lags=c(7,365), instead of having two components with respective lags, it should be done as one component with lags=7 and another with lags = 365/7...

In the ideal world a model should have "monthly", "weekly" and "daily" components for this situation. Not clear, how to get there from lags=c(7,365)...

Make sure that all combinations of models work

1. ETS,
2. ARIMA,
3. Regression.

Each separate should work and their combos should do as well.

Update oes() aligning it with mes()

Update oes(), so that it has:

1. lags and multiple seasonality;
2. Explanatory variables in the same form as mes();
3. Different loss functions.

Make mes() work on small samples

Do this similar to es(), when parameters are set to specific values.

Advanced loss functions to implement

The analytical counterparts of MSEh, TMSE, GTMSE and GPL are still not implemented. This can be useful for high frequency data / small samples.

Selector for the xreg

Create the code for the variables selection in mes, xregDo="select"

Rewrite regression part of ADAM in the input

Make this in the classic alm() style, and xreg should be optional. Rewrite the respective checks in parametersChecker, but don't touch the main part of the code.

Uncertainty in the smoothing parameters and initial states

Several steps to do:

1. Implement stuff with the variance of smoothing parameters,
2. Implement stuff with the variance of initials.
3. Combine the two.

Model selection and model combination mechanisms

This should be done in mes() and omes() in a similar way to how it is currently done in oes() from smooth - calling the function from itself.

Create vignette with basic features of ADAM

This should outline:

1. ETS;
2. ARIMA;
3. Regression;
4. Some of their combinations;
5. forecast() and summary() methods;

Outlier detection mechanism

Introduce the mechanism, preferably in auto.adam() function.

formula parameter

Introduce formula, which defines what variables to use, when it comes to xreg

Use Rectified Normal distribution for the summary

Use Truncated Normal distribution for the summary of smoothing parameters. Things to do:

1. Save bounds type in adam();
2. Depending on the type, get the restrictions;
3. Use qtruncnorm from truncnorm package.

mes simulator

Develop function for the data generation from the basic ETS models with different distributions.

This is needed for the prediction interval and mean of mes().

Separate seasonal and non-seasonal initials

Possible solutions:

1. Separate initial and initialSeason;
2. Accept a list in initial, so that initial[[1]] is the vector of non-seasonal ones and then [[2]], [[3]] correspond to specific seasonalities. If a seasonal is not provided, it should have NA.

ETS(NNN)

This is supposed to switch off the ETS and leave ARIMAX components only.

Develop ETS with other distributions

This means likelihood calculation + prediction intervals for:

1. Inverse Gaussian,
2. Laplace,
3. Logistic,
4. Student's T,
5. Teacher's S,
6. Asymmetric Laplace,
7. Log Normal,
8. Box-Cox Normal.

Write a function returning the matrix of multisteps errors

This should be done similar to the one from es(), but maybe in a vectorised form.

Integrate mes with alm

This implies:

1. is.alm() for the occurrence in mes(),
2. is.oes() for the occurrence in alm(),
3. working predict() and forecast() for both.

Introduce explanatory variables

1. In mes() with the basic checks, similar to alm();
2. In omes() as well.

Deal with the fractional frequencies

This should involve the new type of seasonals based on dummies and a vector of dates for the values of y (date parameter) in mes() and omes()

xreg with predicted values

There should be a mechanism of defining, which variables should be predicted and which should be used as is. A method preparing explanatory variables is needed.

When the variable is marked for prediction this is what should happen inside the function:

1. Predict each marked explanatory variable;
2. Use fitted values for the estimation;
3. Use point forecasts for forecasting;
4. Use covariances between variables for the variance calculation;
5. Use (3) and (4) for the final forecasts.

User defined loss functions

Make it possible to specify loss=f(x) in the function

Mechanism for the missing values treatment

This should be done for mes() for the data, when there are NAs. omes() should treat those cases as ot=0.

The missing values will need to be interpolated using the model itself.

Move adam() to smooth

This involves:

1. Moving C++ code and making sure that there's no conflict with the existing one;
2. Moving R code;
3. Moving tests and vignettes;
4. Making sure that the package passes all the tests;

Potentially:
5. Updating es(), ssarima(), msarima(), gum(), sma(), so that they use the new C++ code instead of the old one.
6. Removal of the old code.

Correct distributions in ADAM

This relates to: lnorm, llaplace, ls and lgnorm and the assumptions for the mean (mu=-sigma^2 / 2). Things that need fixing:

1. Scale calculation;
2. Likelihoods;
3. Prediction intervals;
4. Residuals: standardised and studentised;
5. Outlierdummy;
6. Diagnostic plots;
7. PointLik.

Let persistence accept lists

This can be either named or none, accepting something like:
list(level=0.1,trend=0.2,seasonal=c(0.3,0.1),xreg=c(0.1,0.1,0.1))
If some of the options are not provided, then they are estimated.

If a vector is provided, use values in the mentioned order.

Methods to implement:

1. cvar() - conditional variance,
2. predict(), forecast(),
3. resid(), rstandard(), rstudent(),
4. plot() with which option, similar to alm(),
5. vcov(),
6. confint(),
7. summary() similar to alm().