def train(file_path, P, frac): target, df = create_dataset(file_path) i = 0 rolling_test = [] train_size = int(frac * df.shape[0]) starts = [pd.Timestamp(df.index[0]) for _ in range(len(target))] delay = 0 grouper_train = MultivariateGrouper(max_target_dim=df.shape[0]) grouper_test = MultivariateGrouper(max_target_dim=df.shape[0]) train_ds = ListDataset([{ FieldName.TARGET: targets, FieldName.START: start } for (targets, start) in zip(target[:, 0:train_size - P], starts)], freq='1B') train_ds = grouper_train(train_ds) while train_size + delay < df.shape[0]: delay = int(P) * i test_ds = ListDataset([{ FieldName.TARGET: targets, FieldName.START: start } for (targets, start) in zip(target[:, 0:train_size + delay], starts) ], freq='1B') test_ds = grouper_test(test_ds) rolling_test.append(test_ds) i += 1 estimator = GPVAREstimator(prediction_length=pred_len, context_length=6, freq='1B', target_dim=df.shape[1], trainer=Trainer(ctx="cpu", epochs=200)) return train_ds, rolling_test, estimator, train_size
def load_multivariate_constant_dataset(): metadata, train_ds, test_ds = constant_dataset() grouper_train = MultivariateGrouper(max_target_dim=NUM_SERIES) grouper_test = MultivariateGrouper(max_target_dim=NUM_SERIES) return TrainDatasets( metadata=metadata, train=grouper_train(train_ds), test=grouper_test(test_ds), )
def load_multivariate_datasets(path: Path) -> TrainDatasets: ds = load_datasets(path / "metadata", path / "train", path / "test") target_dim = ds.metadata.feat_static_cat[0].cardinality grouper_train = MultivariateGrouper(max_target_dim=target_dim) grouper_test = MultivariateGrouper(max_target_dim=target_dim) return TrainDatasets( metadata=ds.metadata, train=grouper_train(ds.train), test=grouper_test(ds.test), )
def load_dataset(dataset_name: str, path: Path) -> TrainDatasets: dataset = get_dataset(dataset_name, path, regenerate=False) target_dim = dataset.metadata.feat_static_cat[0].cardinality grouper_train = MultivariateGrouper(max_target_dim=target_dim) grouper_test = MultivariateGrouper(max_target_dim=target_dim) return TrainDatasets( metadata=dataset.metadata, train=grouper_train(dataset.train), test=grouper_test(dataset.test), )
def load_multivariate_constant_dataset(): dataset_info, train_ds, test_ds = constant_dataset() grouper_train = MultivariateGrouper(max_target_dim=10) grouper_test = MultivariateGrouper(num_test_dates=1, max_target_dim=10) metadata = dataset_info.metadata metadata.prediction_length = dataset_info.prediction_length return TrainDatasets( metadata=dataset_info.metadata, train=grouper_train(train_ds), test=grouper_test(test_ds), )
def test_multivariate_grouper_train(univariate_ts, multivariate_ts, train_fill_rule) -> None: univariate_ds = ListDataset(univariate_ts, freq="1D") multivariate_ds = ListDataset(multivariate_ts, freq="1D", one_dim_target=False) grouper = MultivariateGrouper(train_fill_rule=train_fill_rule) assert (list(grouper(univariate_ds))[0]["target"] == list(multivariate_ds) [0]["target"]).all() assert (list(grouper(univariate_ds))[0]["start"] == list(multivariate_ds) [0]["start"])
def test_multivariate_grouper_test(univariate_ts, multivariate_ts, test_fill_rule, max_target_dim) -> None: univariate_ds = ListDataset(univariate_ts, freq="1D") multivariate_ds = ListDataset(multivariate_ts, freq="1D", one_dim_target=False) grouper = MultivariateGrouper( test_fill_rule=test_fill_rule, num_test_dates=2, max_target_dim=max_target_dim, ) for grouped_data, multivariate_data in zip(grouper(univariate_ds), multivariate_ds): assert (grouped_data["target"] == multivariate_data["target"]).all() assert grouped_data["start"] == multivariate_data["start"]
def train(args): freq = args.freq.replace('"', '') prediction_length = args.prediction_length context_length = args.context_length use_feat_dynamic_real = args.use_feat_dynamic_real use_past_feat_dynamic_real = args.use_past_feat_dynamic_real use_feat_static_cat = args.use_feat_static_cat use_log1p = args.use_log1p print('freq:', freq) print('prediction_length:', prediction_length) print('context_length:', context_length) print('use_feat_dynamic_real:', use_feat_dynamic_real) print('use_past_feat_dynamic_real:', use_past_feat_dynamic_real) print('use_feat_static_cat:', use_feat_static_cat) print('use_log1p:', use_log1p) batch_size = args.batch_size print('batch_size:', batch_size) train = load_json(os.path.join(args.train, 'train_'+freq+'.json')) test = load_json(os.path.join(args.test, 'test_'+freq+'.json')) num_timeseries = len(train) print('num_timeseries:', num_timeseries) train_ds = ListDataset(parse_data(train, use_log1p=use_log1p), freq=freq) test_ds = ListDataset(parse_data(test, use_log1p=use_log1p), freq=freq) predictor = None trainer= Trainer(ctx="cpu", epochs=args.epochs, num_batches_per_epoch=args.num_batches_per_epoch, learning_rate=args.learning_rate, learning_rate_decay_factor=args.learning_rate_decay_factor, patience=args.patience, minimum_learning_rate=args.minimum_learning_rate, clip_gradient=args.clip_gradient, weight_decay=args.weight_decay, init=args.init.replace('"', ''), hybridize=args.hybridize) print('trainer:', trainer) cardinality = None if args.cardinality != '': cardinality = args.cardinality.replace('"', '').replace(' ', '').replace('[', '').replace(']', '').split(',') for i in range(len(cardinality)): cardinality[i] = int(cardinality[i]) print('cardinality:', cardinality) embedding_dimension = [min(50, (cat+1)//2) for cat in cardinality] if cardinality is not None else None print('embedding_dimension:', embedding_dimension) algo_name = args.algo_name.replace('"', '') print('algo_name:', algo_name) if algo_name == 'CanonicalRNN': estimator = CanonicalRNNEstimator( freq=freq, prediction_length=prediction_length, context_length=context_length, trainer=trainer, batch_size=batch_size, num_layers=5, num_cells=50, cell_type='lstm', num_parallel_samples=100, cardinality=cardinality, embedding_dimension=10, ) elif algo_name == 'DeepFactor': estimator = DeepFactorEstimator( freq=freq, prediction_length=prediction_length, context_length=context_length, trainer=trainer, batch_size=batch_size, cardinality=cardinality, embedding_dimension=10, ) elif algo_name == 'DeepAR': estimator = DeepAREstimator( freq = freq, # – Frequency of the data to train on and predict prediction_length = prediction_length, # – Length of the prediction horizon trainer = trainer, # – Trainer object to be used (default: Trainer()) context_length = context_length, # – Number of steps to unroll the RNN for before computing predictions (default: None, in which case context_length = prediction_length) num_layers = 2, # – Number of RNN layers (default: 2) num_cells = 40, # – Number of RNN cells for each layer (default: 40) cell_type = 'lstm', # – Type of recurrent cells to use (available: ‘lstm’ or ‘gru’; default: ‘lstm’) dropoutcell_type = 'ZoneoutCell', # – Type of dropout cells to use (available: ‘ZoneoutCell’, ‘RNNZoneoutCell’, ‘VariationalDropoutCell’ or ‘VariationalZoneoutCell’; default: ‘ZoneoutCell’) dropout_rate = 0.1, # – Dropout regularization parameter (default: 0.1) use_feat_dynamic_real = use_feat_dynamic_real, # – Whether to use the feat_dynamic_real field from the data (default: False) use_feat_static_cat = use_feat_static_cat, # – Whether to use the feat_static_cat field from the data (default: False) use_feat_static_real = False, # – Whether to use the feat_static_real field from the data (default: False) cardinality = cardinality, # – Number of values of each categorical feature. This must be set if use_feat_static_cat == True (default: None) embedding_dimension = embedding_dimension, # – Dimension of the embeddings for categorical features (default: [min(50, (cat+1)//2) for cat in cardinality]) # distr_output = StudentTOutput(), # – Distribution to use to evaluate observations and sample predictions (default: StudentTOutput()) # scaling = True, # – Whether to automatically scale the target values (default: true) # lags_seq = None, # – Indices of the lagged target values to use as inputs of the RNN (default: None, in which case these are automatically determined based on freq) # time_features = None, # – Time features to use as inputs of the RNN (default: None, in which case these are automatically determined based on freq) # num_parallel_samples = 100, # – Number of evaluation samples per time series to increase parallelism during inference. This is a model optimization that does not affect the accuracy (default: 100) # imputation_method = None, # – One of the methods from ImputationStrategy # train_sampler = None, # – Controls the sampling of windows during training. # validation_sampler = None, # – Controls the sampling of windows during validation. # alpha = None, # – The scaling coefficient of the activation regularization # beta = None, # – The scaling coefficient of the temporal activation regularization batch_size = batch_size, # – The size of the batches to be used training and prediction. # minimum_scale = None, # – The minimum scale that is returned by the MeanScaler # default_scale = None, # – Default scale that is applied if the context length window is completely unobserved. If not set, the scale in this case will be the mean scale in the batch. # impute_missing_values = None, # – Whether to impute the missing values during training by using the current model parameters. Recommended if the dataset contains many missing values. However, this is a lot slower than the default mode. # num_imputation_samples = None, # – How many samples to use to impute values when impute_missing_values=True ) elif algo_name == 'DeepState': estimator = DeepStateEstimator( freq=freq, prediction_length=prediction_length, trainer=trainer, batch_size=batch_size, use_feat_dynamic_real=use_feat_dynamic_real, use_feat_static_cat=use_feat_static_cat, cardinality=cardinality, ) elif algo_name == 'DeepVAR': estimator = DeepVAREstimator( # use multi freq=freq, prediction_length=prediction_length, context_length=context_length, trainer=trainer, batch_size=batch_size, target_dim=96, ) elif algo_name == 'GaussianProcess': # # TODO # estimator = GaussianProcessEstimator( # freq=freq, # prediction_length=prediction_length, # context_length=context_length, # trainer=trainer, # batch_size=batch_size, # cardinality=num_timeseries, # ) pass elif algo_name == 'GPVAR': estimator = GPVAREstimator( # use multi freq=freq, prediction_length=prediction_length, context_length=context_length, trainer=trainer, batch_size=batch_size, target_dim=96, ) elif algo_name == 'LSTNet': estimator = LSTNetEstimator( # use multi freq=freq, prediction_length=prediction_length, context_length=context_length, num_series=96, skip_size=4, ar_window=4, channels=72, trainer=trainer, batch_size=batch_size, ) elif algo_name == 'NBEATS': estimator = NBEATSEstimator( freq=freq, prediction_length=prediction_length, context_length=context_length, trainer=trainer, batch_size=batch_size, ) elif algo_name == 'DeepRenewalProcess': estimator = DeepRenewalProcessEstimator( freq=freq, prediction_length=prediction_length, context_length=context_length, trainer=trainer, batch_size=batch_size, num_cells=40, num_layers=2, ) elif algo_name == 'Tree': estimator = TreePredictor( freq = freq, prediction_length = prediction_length, context_length = context_length, n_ignore_last = 0, lead_time = 0, max_n_datapts = 1000000, min_bin_size = 100, # Used only for "QRX" method. use_feat_static_real = False, use_feat_dynamic_cat = False, use_feat_dynamic_real = use_feat_dynamic_real, cardinality = cardinality, one_hot_encode = False, model_params = {'eta': 0.1, 'max_depth': 6, 'silent': 0, 'nthread': -1, 'n_jobs': -1, 'gamma': 1, 'subsample': 0.9, 'min_child_weight': 1, 'colsample_bytree': 0.9, 'lambda': 1, 'booster': 'gbtree'}, max_workers = 4, # default: None method = "QRX", # "QRX", "QuantileRegression", "QRF" quantiles=None, # Used only for "QuantileRegression" method. model=None, seed=None, ) elif algo_name == 'SelfAttention': # # TODO # estimator = SelfAttentionEstimator( # freq=freq, # prediction_length=prediction_length, # context_length=context_length, # trainer=trainer, # batch_size=batch_size, # ) pass elif algo_name == 'MQCNN': estimator = MQCNNEstimator( freq=freq, prediction_length=prediction_length, context_length=context_length, trainer=trainer, batch_size=batch_size, use_past_feat_dynamic_real=use_past_feat_dynamic_real, use_feat_dynamic_real=use_feat_dynamic_real, use_feat_static_cat=use_feat_static_cat, cardinality=cardinality, embedding_dimension=embedding_dimension, add_time_feature=True, add_age_feature=False, enable_encoder_dynamic_feature=True, enable_decoder_dynamic_feature=True, seed=None, decoder_mlp_dim_seq=None, channels_seq=None, dilation_seq=None, kernel_size_seq=None, use_residual=True, quantiles=None, distr_output=None, scaling=None, scaling_decoder_dynamic_feature=False, num_forking=None, max_ts_len=None, ) elif algo_name == 'MQRNN': estimator = MQRNNEstimator( freq=freq, prediction_length=prediction_length, context_length=context_length, trainer=trainer, batch_size=batch_size, ) elif algo_name == 'Seq2Seq': # # TODO # estimator = Seq2SeqEstimator( # freq=freq, # prediction_length=prediction_length, # context_length=context_length, # trainer=trainer, # cardinality=cardinality, # embedding_dimension=4, # encoder=Seq2SeqEncoder(), # decoder_mlp_layer=[4], # decoder_mlp_static_dim=4 # ) pass elif algo_name == 'SimpleFeedForward': estimator = SimpleFeedForwardEstimator( num_hidden_dimensions=[40, 40], prediction_length=prediction_length, context_length=context_length, freq=freq, trainer=trainer, batch_size=batch_size, ) elif algo_name == 'TemporalFusionTransformer': estimator = TemporalFusionTransformerEstimator( prediction_length=prediction_length, context_length=context_length, freq=freq, trainer=trainer, batch_size=batch_size, hidden_dim = 32, variable_dim = None, num_heads = 4, num_outputs = 3, num_instance_per_series = 100, dropout_rate = 0.1, # time_features = [], # static_cardinalities = {}, # dynamic_cardinalities = {}, # static_feature_dims = {}, # dynamic_feature_dims = {}, # past_dynamic_features = [] ) elif algo_name == 'DeepTPP': # # TODO # estimator = DeepTPPEstimator( # prediction_interval_length=prediction_length, # context_interval_length=context_length, # freq=freq, # trainer=trainer, # batch_size=batch_size, # num_marks=len(cardinality) if cardinality is not None else 0, # ) pass elif algo_name == 'Transformer': estimator = TransformerEstimator( freq=freq, prediction_length=prediction_length, trainer=trainer, batch_size=batch_size, cardinality=cardinality, ) elif algo_name == 'WaveNet': estimator = WaveNetEstimator( freq=freq, prediction_length=prediction_length, trainer=trainer, batch_size=batch_size, cardinality=cardinality, ) elif algo_name == 'Naive2': # TODO Multiplicative seasonality is not appropriate for zero and negative values predictor = Naive2Predictor(freq=freq, prediction_length=prediction_length, season_length=context_length) elif algo_name == 'NPTS': predictor = NPTSPredictor(freq=freq, prediction_length=prediction_length, context_length=context_length) elif algo_name == 'Prophet': def configure_model(model): model.add_seasonality( name='weekly', period=7, fourier_order=3, prior_scale=0.1 ) return model predictor = ProphetPredictor(freq=freq, prediction_length=prediction_length, init_model=configure_model) elif algo_name == 'ARIMA': predictor = RForecastPredictor(freq=freq, prediction_length=prediction_length, method_name='arima', period=context_length, trunc_length=len(train[0]['target'])) elif algo_name == 'ETS': predictor = RForecastPredictor(freq=freq, prediction_length=prediction_length, method_name='ets', period=context_length, trunc_length=len(train[0]['target'])) elif algo_name == 'TBATS': predictor = RForecastPredictor(freq=freq, prediction_length=prediction_length, method_name='tbats', period=context_length, trunc_length=len(train[0]['target'])) elif algo_name == 'CROSTON': predictor = RForecastPredictor(freq=freq, prediction_length=prediction_length, method_name='croston', period=context_length, trunc_length=len(train[0]['target'])) elif algo_name == 'MLP': predictor = RForecastPredictor(freq=freq, prediction_length=prediction_length, method_name='mlp', period=context_length, trunc_length=len(train[0]['target'])) elif algo_name == 'SeasonalNaive': predictor = SeasonalNaivePredictor(freq=freq, prediction_length=prediction_length) else: print('[ERROR]:', algo_name, 'not supported') return if predictor is None: try: predictor = estimator.train(train_ds, test_ds) except Exception as e: print(e) try: grouper_train = MultivariateGrouper(max_target_dim=num_timeseries) train_ds_multi = grouper_train(train_ds) test_ds_multi = grouper_train(test_ds) predictor = estimator.train(train_ds_multi, test_ds_multi) except Exception as e: print(e) forecast_it, ts_it = make_evaluation_predictions( dataset=test_ds, # test dataset predictor=predictor, # predictor num_samples=100, # number of sample paths we want for evaluation ) forecasts = list(forecast_it) tss = list(ts_it) # print(len(forecasts), len(tss)) evaluator = Evaluator(quantiles=[0.1, 0.5, 0.9]) agg_metrics, item_metrics = evaluator(iter(tss), iter(forecasts), num_series=len(test_ds)) print(json.dumps(agg_metrics, indent=4)) model_dir = os.path.join(args.model_dir, algo_name) if not os.path.exists(model_dir): os.makedirs(model_dir) predictor.serialize(Path(model_dir))
def train(bucket, seq, algo, freq, prediction_length, epochs, learning_rate, hybridize, num_batches_per_epoch): #create train dataset df = pd.read_csv(filepath_or_buffer=os.environ['SM_CHANNEL_TRAIN'] + "/train.csv", header=0, index_col=0) training_data = ListDataset([{ "start": df.index[0], "target": df.usage[:], "item_id": df.client[:] }], freq=freq) #create test dataset df = pd.read_csv(filepath_or_buffer=os.environ['SM_CHANNEL_TEST'] + "/test.csv", header=0, index_col=0) test_data = ListDataset([{ "start": df.index[0], "target": df.usage[:], "item_id": 'client_12' }], freq=freq) hook = Hook.create_from_json_file() #determine estimators################################## if algo == "DeepAR": estimator = DeepAREstimator( freq=freq, prediction_length=prediction_length, context_length=1, trainer=Trainer(ctx="cpu", epochs=epochs, learning_rate=learning_rate, hybridize=hybridize, num_batches_per_epoch=num_batches_per_epoch)) #train the model predictor = estimator.train(training_data=training_data) print("DeepAR training is complete SUCCESS") elif algo == "SFeedFwd": estimator = SimpleFeedForwardEstimator( freq=freq, prediction_length=prediction_length, trainer=Trainer(ctx="cpu", epochs=epochs, learning_rate=learning_rate, hybridize=hybridize, num_batches_per_epoch=num_batches_per_epoch)) #train the model predictor = estimator.train(training_data=training_data) print("training is complete SUCCESS") elif algo == "lstnet": # Needed for LSTNet ONLY grouper = MultivariateGrouper(max_target_dim=6) training_data = grouper(training_data) test_data = grouper(test_data) context_length = prediction_length num_series = 1 skip_size = 1 ar_window = 1 channels = 4 estimator = LSTNetEstimator( freq=freq, prediction_length=prediction_length, context_length=context_length, num_series=num_series, skip_size=skip_size, ar_window=ar_window, channels=channels, trainer=Trainer(ctx="cpu", epochs=epochs, learning_rate=learning_rate, hybridize=hybridize, num_batches_per_epoch=num_batches_per_epoch)) #train the model predictor = estimator.train(training_data=training_data) print("training is complete SUCCESS") elif algo == "seq2seq": estimator = MQCNNEstimator( freq=freq, prediction_length=prediction_length, trainer=Trainer(ctx="cpu", epochs=epochs, learning_rate=learning_rate, hybridize=hybridize, num_batches_per_epoch=num_batches_per_epoch)) #train the model predictor = estimator.train(training_data=training_data) print("training is complete SUCCESS") else: estimator = TransformerEstimator( freq=freq, prediction_length=prediction_length, trainer=Trainer(ctx="cpu", epochs=epochs, learning_rate=learning_rate, hybridize=hybridize, num_batches_per_epoch=num_batches_per_epoch)) #train the model predictor = estimator.train(training_data=training_data) print("training is complete SUCCESS") ################################################### #evaluate trained model on test data forecast_it, ts_it = make_evaluation_predictions(test_data, predictor, num_samples=100) print("EVALUATION is complete SUCCESS") forecasts = list(forecast_it) tss = list(ts_it) evaluator = Evaluator(quantiles=[0.1, 0.5, 0.9]) agg_metrics, item_metrics = evaluator(iter(tss), iter(forecasts), num_series=len(test_data)) print("METRICS retrieved SUCCESS") #bucket = "bwp-sandbox" mainpref = "gluonts/blog-models/" prefix = mainpref + str(seq) + "/" agg_df = pd.DataFrame(agg_metrics, index=[0]) file = "metrics" + str(seq) + ".csv" os.system('mkdir metrics') cspath = os.path.join('metrics', file) agg_df.to_csv(cspath) s3.upload_file(cspath, bucket, mainpref + "metrics/" + file) hook.save_scalar("MAPE", agg_metrics["MAPE"], sm_metric=True) hook.save_scalar("RMSE", agg_metrics["RMSE"], sm_metric=True) hook.save_scalar("MASE", agg_metrics["MASE"], sm_metric=True) hook.save_scalar("MSE", agg_metrics["MSE"], sm_metric=True) print("MAPE:", agg_metrics["MAPE"]) #save the model predictor.serialize(pathlib.Path(os.environ['SM_MODEL_DIR'])) uploadDirectory(os.environ['SM_MODEL_DIR'], prefix, bucket) return predictor