How to export GluonTS Estimator's trained_net model

[Giangblackk]

I'm trying to export the trained_net from the output of Estimator.train_model function.

Here is the basic:

from gluonts.dataset import common
from gluonts.model import deepar
from gluonts.trainer import Trainer

import pandas as pd
import mxnet as mx

url = "https://raw.githubusercontent.com/numenta/NAB/master/data/realTweets/Twitter_volume_AMZN.csv"
df = pd.read_csv(url, header=0, index_col=0)
data = common.ListDataset(
    [{"start": df.index[0], "target": df.value[:"2015-04-05 00:00:00"]}], freq="5min"
)

trainer = Trainer(epochs=1)
estimator = deepar.DeepAREstimator(freq="5min", prediction_length=12, trainer=trainer)
training_output = estimator.train_model(training_data=data)
trained_net = training_output.trained_net

I want to export the trained_net, so I tried:

training_output.trained_net.export('trained_net')

But I got error:

~/miniconda3/envs/mxnet/lib/python3.7/site-packages/mxnet/gluon/block.py in export(self, path, epoch, remove_amp_cast)
   1238         if not self._cached_graph:
   1239             raise RuntimeError(
-> 1240                 "Please first call block.hybridize() and then run forward with "
   1241                 "this block at least once before calling export.")
   1242         sym = self._cached_graph[1]

RuntimeError: Please first call block.hybridize() and then run forward with this block at least once before calling export.

So I tried to hybridize and run foward (I don't really know what variable to put into foward function, so if you know it, please tell me too):

data0 = next(iter(data))
print(data0)
input_tensor = mx.nd.array(data0['target'])
trained_net(input_tensor)

Here is the error:

~/miniconda3/envs/mxnet/lib/python3.7/site-packages/mxnet/gluon/block.py in __call__(self, *args)
    680             hook(self, args)
    681 
--> 682         out = self.forward(*args)
    683 
    684         for hook in self._forward_hooks.values():

~/miniconda3/envs/mxnet/lib/python3.7/site-packages/mxnet/gluon/block.py in forward(self, x, *args)
   1297                                      'Find all contexts = {}'.format(ctx_set))
   1298                 with ctx:
-> 1299                     return self._call_cached_op(x, *args)
   1300             with ctx:
   1301                 try:

~/miniconda3/envs/mxnet/lib/python3.7/site-packages/mxnet/gluon/block.py in _call_cached_op(self, *args)
   1043     def _call_cached_op(self, *args):
   1044         if self._cached_op is None:
-> 1045             self._build_cache(*args)
   1046         assert self._cached_op, "Gluon failed to build the cache. " \
   1047                                 "This should never happen. " \

~/miniconda3/envs/mxnet/lib/python3.7/site-packages/mxnet/gluon/block.py in _build_cache(self, *args)
    922 
    923     def _build_cache(self, *args):
--> 924         data, out = self._get_graph(*args)
    925         data_names = {data.name: i for i, data in enumerate(data)}
    926         params = self.collect_params()

~/miniconda3/envs/mxnet/lib/python3.7/site-packages/mxnet/gluon/block.py in _get_graph(self, *args)
    914             params = {i: j.var() for i, j in self._reg_params.items()}
    915             with self.name_scope():
--> 916                 out = self.hybrid_forward(symbol, *grouped_inputs, **params)  # pylint: disable=no-value-for-parameter
    917             out, self._out_format = _flatten(out, "output")
    918 

TypeError: hybrid_forward() missing 7 required positional arguments: 'feat_static_real', 'past_time_feat', 'past_target', 'past_observed_values', 'future_time_feat', 'future_target', and 'future_observed_values'

[Vzlentin]

up

[MarleneBs]

I don't have an answer right now, but I have a follow-up question:
Why does everyone always use ListData? I now use pandas dataset and simply write in the features which should be used as such, is that also possible?

by trained_net do you simply mean the model?
There is a code example for this on the page:
from pathlib import Path

predictor.serialize(Path("/tmp/"))

But I don't know how you can select where this is stored.

[Msaleh87]

Hi,
If you are referring to saving your model to use it somewhere else without having to train it from scratch you could use this code:

from pathlib import Path
predictor.serialize(Path(r"the path to your folder where you want to save the model"))

This will save some files in the folder for your model. If you want to load the model, you could use:

from gluonts.model.predictor import Predictor
predictor = Predictor.deserialize(Path(r"Same path where you saved your model in the first step))

[Msaleh87]

If you are trying to find the forecasted data, you could simply find it using forecast_e.mean. Also, this is a code to find the forecasted data and save it in a data frame with the actual data:

forecasts = list(forecast_it)
tss = list(ts_it)

ts_e = tss[0]
forecast_e = forecasts[0]

f_length = len(forecast_e.mean)

data = {
        'timestamp': ts_e.index[-f_length:].strftime("%Y-%m-%d %H:%M:%S"),
        'forecast': forecast_e.mean,
        'Real data' : ts_e[-f_length:][0].values
    }
dff = pd.DataFrame(data)

# this is to plot it
dff = dff.set_index('timestamp')
dff.plot()

[Msaleh87]

If you want to export the training data output of the model vs the real data. I am not sure if this is possible, I know it is possible in Neural Prophet.
I would suggest check the documentation: https://ts.gluon.ai/stable/tutorials/forecasting/extended_tutorial.html#Getting-the-forecasts
This section shows how to extract the forecast data vs the real data.
I believe what you are looking for is the model performance on the training dataset vs the actual training dataset. Check the documentation and please share your findings, if any. Thanks

[MarleneBs]

thank you, i think i've safed the forecast in an other way, as a pickle file and the mean_ts for the values?
What data extension must the file for the predictor have ? tmp ?

[MarleneBs]

Oh right, it says on the page how to save the forecast. I have now saved the entire forecast object as a pick file, but it should still be possible to generate it from this, right?

Do I then get a normal dataframe with the method shown on the GluonTS page, which I can also process with scikitlearn as an example?