Nixtla's Open Source Time Series Ecosystem.

Nixtla Community

Hello, I have a question about `statsforecast`. Does it take missing values into consideration? From what I have seen so far when testing it, it only seems to use the timestamps of entries for ordering them and not for anything else. At least the cross-validation and the predict method behave this way, I am not sure about the fit method. The cross-validation method seems to iterate over windows of constant size, regardless of how they are placed in time. And the forecast method just forecasts the next K days, regardless of the datetimes specified in the `X_df` argument.

Hi! For the time being, there's no special functionality for holidays, so treat them as an exogenous regressor.

Hey <@U04BX22QMHT>! Yes, that’s the expected behavior. Classic intermittent models such as adida, imapa, and croston produce constant forecasts. Those models can be taught as a mean model specialized in data with zeros. Therefore, these models do not consider exogenous variables, only the time series.  You could include trend and seasonality with AutoETS and AutoTheta. They usually work well with intermittent data.

Time_series_cross_validation.png

Here's what I meant for Time Series cross-validation:

Expanding_window_cross_validation.png

And here is what I've meant for Expanding window cross_validation (in statsforecast you can set the `step_size` , which is missing from mlforecast) Is there a method to do Expanding window cross_validation in mlforecast too?

As far as I reckon modifying the `offset` variable from the `backtest_splits()` function did what I wanted (Expanding window with `step_size=1`)

Previous:

```def backtest_splits(
    data,
    n_windows: int,
    window_size: int,
    freq: Union[pd.offsets.BaseOffset, int],
    time_col: str = "ds",
):
    for i in range(n_windows):
        offset = (n_windows - i) * window_size
        ...```
Now:

```def backtest_splits(
    data,
    n_windows: int,
    window_size: int,
    freq: Union[pd.offsets.BaseOffset, int],
    time_col: str = "ds",
    expending_window = int,
):
    if expending_window == 1:

        for i in range(n_windows):
            offset = window_size+n_windows-1-i
            ... (the rest of the code is left unchanged)
    else:
        Previous implementation```
Also I added expending_window as an argument in the cross_validation method from the MLForecast class like so:

```def cross_validation(
        self,
        data: pd.DataFrame,
        n_windows: int,
        window_size: int,
        id_col: str,
        time_col: str,
        target_col: str,
        expending_window: int = 0,
        static_features: Optional[List[str]] = None,
        dropna: bool = True,
        keep_last_n: Optional[int] = None,
        dynamic_dfs: Optional[List[pd.DataFrame]] = None,
        predict_fn: Optional[Callable] = None,
        **predict_fn_kwargs,
    ):```
If it's not specified it will use the previous implementation, if it's 1 it will use Expanding window with size of 1. Most probably not the best aproach but I needed it fast

hey <@U04CLTA2EJD>! Regarding the cross-validation methods, you’re right. Currently, you can’t perform expanding window cross-validation using mlforecast. The underlying `step_size` in mlforecast is `window_size` . We are working on matching the methods, arguments, and functionality between mlforecast and statsforecast, we will prioritize the cross validation method :slightly_smiling_face:

On the second point, although both evaluation techniques are valid, in practice it is preferred to calculate the loss on each fold separately and then average it (as in mlforecast). We will update the statsforecast documentation to reflect this. :raised_hands:

Hi! We decided to make the libraries completely independent. Models are currently not reusable in other libraries.
We are working into making everything compatible :slightly_smiling_face:

Thank you for such a quick reply! Appreciated

This seams like a question for <@U0316L4HWQ7>.

Thank you for a quick reply, looking forward to the answer!

hey <@U04FX0UGC1H>! Currently, `statsforecast`  does not support access to the `train_ds`  values. Since our models don’t need the `ds` information, we omitted that possibility (they receive the time series as a numpy array). Even if the time series is not uniformly spaced, StatsForecast passes the values to the models.

We are planning a refactor to allow the models to access the full dataframe  (including `ds`) instead of just the numpy array values. Please help us open an issue to prioritize this new feature. :slightly_smiling_face:

Where you thinking to open a PR in stats, ml o neural <@U04FX0UGC1H>?

Thank you for such a quick and clear response, <@U0316L4HWQ7>!
&gt; Currently, `statsforecast`  does not support access to the `train_ds`  values
Just to make sure, `mlforecast` and `neuralforecast` also doesn’t support `ds` ?

<@U035DR8HD6D> <https://github.com/Nixtla/statsforecast/issues/373>
thank you!

yes, `mlforecast` and `neuralforecast` also do not support it at the moment. `mlforecast`   produces features based on `ds,` but the fit method of the models don’t receive the complete `ds` values

hey <@U04CVB9M7L1>! Would you happen to have an example of how you are running statsforecast?

image.png

<@U04CVB9M7L1>: could you please also share the header of your dataframe and the code where you define `sf` .?

And how many weeks do you have in that df?

It says that the data is Nonseasonal data

Good find <@U03L39VLJBA>. I saw him present a similar approach earlier this year at the ISF in Oxford, but that was focused on user traffic at Meta. Looks like he's applied it to load forecasting now.

```fcst = MLForecast( 
                 models=models, 
                 freq='W-MON',
                 differences=data['differences']
                )```

```models = [lgb.LGBMRegressor()]
fcst = MLForecast( 
                 models=models, 
                 freq='W-MON',
                 differences=[]
                )```

Do you mean using the empty list as differences?

I ve noticed that if I left the differences as an empty list the predicted values are the same 

The differences argument is there to specify sequential differences to apply to the series, e.g. [1,12] first subtracts the previous value and then the 12th. If you don't pass anything or pass the empty list it won't take any. What are you trying to accomplish?

We are working on a weekly timeseries dataset, and didn't quite know what that argument did. We've seen that if we set `differences = [52]`  the output of the predictions wasn't the same on the whole horizon. We've set `differenences = [52]` as a suggestion from <@U0316L4HWQ7> in a previous thread to capture the yearly trend &amp; seasonalities.

Mostly I was wondering if there's something else we should do to our data (in case we don't want to use differences) to not predict the same values for the whole horizon

Maybe a straight line is the best prediction. What does your data look like?

Thanks a lot! Have you tried different values for the seasonal length parameter ? 

What are you passing to predict and do you have exogenous variables?

Hi all, we would like your support here: <https://www.linkedin.com/posts/activity-7012165119644180480-ewnO?utm_source=share&amp;utm_medium=member_desktop>.

My personal vote is for Nixtla :rocket: will be interesting to see final results

Screenshot 2022-12-26 at 16.11.45.png

Awesome Time Series has started to have Python section filled up.

Stumbled upon this one <https://github.com/alsabtay/ATAforecasting> claims performed well on M3 and M4. Claims superior to ETS and ARIMA

Partage d’écran - 2022-12-26 18 h 41 min 11 s.webm

I'm interested in including exogenous variables using AutoETS and how this was implemented. When I looked at the source code, it seemed like X is not used during e.g. 'fit()' or 'predict()'. Should I conclude from this that AutoETS cannot use exogenous variables? Is there an overview that indicates which models can('t) handle exogenous variables?

hey <@U04GN9NQV9C>! Currently, only AutoARIMA and MSTL (with AutoARIMA as a trend forecaster) can handle exogenous variables. Do not hesitate to open an issue if you want other models to support exogenous variables. :slightly_smiling_face:

Thanks, I will keep that in mind in case I find out how to do it (and the approach seems successful).

<https://stats.stackexchange.com/questions/220830/holt-winters-with-exogenous-regressors-in-r>

<https://www.monash.edu/business/econometrics-and-business-statistics/research/publications/ebs/wp02-15.pdf>

I was personally interested in doing it for exponential smoothing, however no such implementation seems to be publicly available.

Do Nixtla libraries have tests for trend and stationary and decomposition under the hood? Was wondering if some preprocessing is done in terms of trend and seasonality and what sorts of statistical tests the libraries use <@U035DR8HD6D> <@U0316L4HWQ7> please?

hey <@U04BX22QMHT>! Currently, `AutoETS`  does not support seasonalities greater than 24. We are working on extending its functionality. In the meantime, you could try using the `MSTL`  model with `trend_forecaster=AutoETS()`  (<https://nixtla.github.io/statsforecast/examples/multipleseasonalities.html>)

wait does `neuralforecast` accept a tz-aware `ds` column!? it seems to work locally but has anyone tried this?

Hey <@U04BX22QMHT>! The HistoricAverage model takes the entire history of the time series to produce forecasts. You could try using <https://nixtla.github.io/statsforecast/models.html#windowaverage|WindowAverage>. With it, you can specify the `window_size`  argument. For example, `WindowAverage(window_size=4)`  will average the last 4 observations to produce forecasts.

And how are the forecasts produced? Is it a rolling forecast of the last 4 weeks? Or is it just a single value spread out over the fcast horizon?

I would like the forecast to be rolling, like to always take into account also the last forecasted value when it makes the average for the window.

Do you happen to have an implementation also for Exponential moving average?

I see. Currently, an autoregressive window average is not supported. But both models (including the exponential moving average) are special cases of an `AR(p)`  model with predefined coefficients (`1/p`  in the case of the autoregressive window average). We are extending the `ARIMA` family to include the `AR`  model separately, and we will have the option to specify the coefficients. Please help us open an issue on the statsforecast repo.  :slightly_smiling_face:

Okay, will do that.
And also will fill in an issue

Hey <@U03DDFKMT0X>! under the hood, neuralforecast considers the last `ds`  value of each time series and adds the `freq`  argument (previously converted to an `offset` object). So, if  the `ds`  column is correctly formatted (pandas datetime, tz inclusive), there should be no problem

Hello, why we don't use the cross validation method in exogenous variable tutorial? Just making sure I'm not implementing something incorrectly.

Hi Jose! Right now we're updating our tutorials, and the exogenous regressors notebook is one we're currently working on.

Now, cross validation is a method for evaluating and comparing the performance of different models, that may or not include exogenous regressors.

ah perfect, I'm going to try it with different lags of the exogenous variable

I can try implementing it and pass the notebook along if that will help for the tutorial

AutoARIMA is one of the models that can use exogenous regressors, but you need to add them as described in the current notebook (meaning as an additional column after the 'y' column).

Thank you for trying to help; we actually changed the tutorial so that it uses an example from the M5 Competition.

With that example, it should be clearer how to use exogenous regressors (in this case, price and special events).

Hi Farzad. The confidence levels of the seasonal naive are computed as explained here: <https://otexts.com/fpp3/prediction-intervals.html>

hi <@U040AMG6N69>! currently `stepwise=False`  is not supported, we are working on including the functionality. I’ll let you know once it’s available

hi <@U04AMQ5C6AJ>

You can use the `arima_string`  function. Here’s an example,

sf = StatsForecast(
    df=all_leads_weekly_exo_train,
    models=[AutoARIMA(season_length=52)],
    freq='W',
    n_jobs=-1)

arima_string(sf.models[0].model_)

```AttributeError: 'AutoARIMA' object has no attribute 'model_'```


Doesn't seem to work this way, are there two AutoARIMA objects?

To access the fitted models’ information, you must call the `fit`  method first. This method will generate the `fitted_`  attribute, which contains the fitted models. Then you could call `arima_string`  on the specific model and time series. Here’s an example,

1. It is
2. They do <https://nixtla.github.io/statsforecast/models.html#exponentialsmoothing>

Except it doesn't have a window, it uses all data. Not sure if they have a real EMA.

Yeah, I've seen that, I was more curious about the real EMA

But really appreciate your answer <@U04F4Q0FRUM> :smiley: