Optional features explanation in the documentation of GlounTs DeepAr is not clear

[Msaleh87]

This is the definition/explanation of the features in the documentation: https://ts.gluon.ai/stable/tutorials/forecasting/extended_tutorial.html#Use-your-time-series-and-features

feat_static_cat: static (over time) categorical features, list with dimension equal to the number of features

feat_static_real: static (over time) real features, list with dimension equal to the number of features

feat_dynamic_cat: dynamic (over time) categorical features, array with shape equal to (number of features, target length)

feat_dynamic_real: dynamic (over time) real features, array with shape equal to (number of features, target length)

Could you please give some examples of each feature and how to use it in the estimator? Or confirm/ correct my assumptions. Also, would it matter if I input feat_static_real as feat_static_cat

I am assuming that:
if I have a list that contains 1's for weekdays and 0's for weekends, then this list should be included under feat_static_real
if the same list has the words "weekend" and "weekday", then we should use feat_static_cat
If we have the temperature as a feature, then we should use feat_dynamic_real
If we have "rainy", "sunny" and so on then we use feat_dynamic_cat

What about the hour of the day, day of the week, month, or year? I read in other discussions that we should use them as time_feat in the training_data, for example:

training_data = ListDataset([{"start": df_input.index[0],
                              "target": df_input.Load[:'end_date'],

                              'time_feat': [df_input.DayofWeek[:'end_date'], # <----------------
                                            df_input.Hour[:'end_date],] }], # <----------------
                           freq = "freq")

I don't think we need to enable anything in the estimator for the time_feat, correct?

[kaleming]

Hi @Msaleh87,
Most of the time I just use feat_dynamic_real to specify temporal features and feat_static_cat to specify which category the target parameters belongs to. For instance, if I am analyzing sales from some specify SKU. On feat_static_cat I would set each store, brand, city using labeled numeric variables. i.e [1, 1, 2]

On this folder you can check some of the time_feat scripts. Here you can see that gluonts creates some of these features automatically depending on time frame. For instance:

If you set a 5 minute time frame, it will probably create these lags:

     lags = (
         _make_lags_for_minute(offset.n)
         + _make_lags_for_hour(offset.n / 60)
         + _make_lags_for_day(offset.n / (60 * 24))
         + _make_lags_for_week(offset.n / (60 * 24 * 7))
     )

As well these features:

        offsets.Minute: [
            MinuteOfHour,
            HourOfDay,
            DayOfWeek,
            DayOfMonth,
            DayOfYear,
        ],

[Msaleh87]

@kaleming so you are saying that I don't have to explicitly specify the hour of the day, the day of the week, the month of the year, and so on, because the model inherently tries to do so?
Also, I wanted to add weekends, weekdays, and holidays, all in the same feature. Meaning, in one column, If it's an off day (not a working day) then it's a 0 and if it is a working day then its a 1, and input it as 'feat_dynamic_cat' or 'feat_dynamic_real', is that correct? and do I have to do that or the model takes care of this inherently as well?

That's my code for training data:

training_data = ListDataset([{"start": df_input.index[0],
                              "target": df_input.Load[:'end_date'],

                              'time_feat': [df_input.DayofWeek[:'end_date'], # <---- 1 for Mondays, 2 for Tuesdays, 3 for Wednsdays and so on
                                            df_input.Hour[:'end_date],] }], # <----- 1 to 24
                           freq = "freq")

Thanks

[kaleming]

Yes, most of these features are automatically generated. Have a look on this notebook. He used feat_dynamic_real to specify holidays like [0, 0, 1, 0, ...] where 0 is not holiday and 1 is holiday.

[Msaleh87]

@kaleming I see in the notebook he used in the estimator use_feat_static_cat=True. In my code, I used feat_static_cat in the training data set and when I tried to use use_feat_static_cat=True, I got an error. So I added it to the training dataset and didn't have to specify it in the estimator. I am thinking that I am using a newer version and I don't have to specify use_feat_static_cat=True. Just double-checking here. This is my code:

estimator = DeepAREstimator(freq = '5min',
                           context_length = 4*24*12,   
                           prediction_length = 2*24*12,
                           num_layers = 2,
                           num_cells = 128, 
                           #cardinality = 'auto',
                           scaling = True,
                           #use_feat_dynamic_real =True,
                           trainer = Trainer(epochs= 40, batch_size = 349 ,num_batches_per_epoch= 288 ,learning_rate = 0.001,hybridize=True, callbacks=[scheduler]), 
                           lags_seq = get_lags_for_frequency("5min", lag_ub=14*24*12))  

from gluonts.dataset.common import ListDataset


training_data = ListDataset([{"start": df_input.index[0],
                              "target": df_input.Load[:'2022-03-07 04:50:00'],

                              'feat_dynamic_cat': [df_input.DofW[:'2022-03-07 04:50:00']],

                              'time_feat': [time_feat_df.DayofWeek[:'2022-03-07 04:50:00'],
                                            time_feat_df.Hour[:'2022-03-07 04:50:00'],] }],
                           freq = "5min")

I will surely add the weekends and weekdays as feat_dynamic_real, I just wanted to make sure that I am using feat_dynamic_cat correctly.

[Msaleh87]

     lags = (
         _make_lags_for_minute(offset.n)
         + _make_lags_for_hour(offset.n / 60)
         + _make_lags_for_day(offset.n / (60 * 24))
         + _make_lags_for_week(offset.n / (60 * 24 * 7))
     )

@kaleming how far these lags go. Is it specified by lags_seq = get_lags_for_frequency("5min", lag_ub=14*24*12))
So in every batch_size it looks back by lag_ub=14*24*12 and checks for hour, day, week patterns? Or it looks throughout the whole data set?