def create_predictor(self, transformation: Transformation,
trained_network: HybridBlock) -> Predictor:
prediction_network = GPVARPredictionNetwork(
target_dim=self.target_dim,
target_dim_sample=self.target_dim,
num_parallel_samples=self.num_parallel_samples,
num_layers=self.num_layers,
num_cells=self.num_cells,
cell_type=self.cell_type,
history_length=self.history_length,
context_length=self.context_length,
prediction_length=self.prediction_length,
dropout_rate=self.dropout_rate,
lags_seq=self.lags_seq,
scaling=self.scaling,
distr_output=self.distr_output,
conditioning_length=self.conditioning_length,
)
copy_parameters(trained_network, prediction_network)
return RepresentableBlockPredictor(
input_transform=transformation,
prediction_net=prediction_network,
batch_size=self.trainer.batch_size,
freq=self.freq,
prediction_length=self.prediction_length,
ctx=self.trainer.ctx,
output_transform=self.output_transform,
)
def create_predictor(
self, transformation: Transformation,
trained_network: HybridBlock) -> RepresentableBlockPredictor:
prediction_network = SelfAttentionPredictionNetwork(
context_length=self.context_length,
prediction_length=self.prediction_length,
d_hidden=self.model_dim,
m_ffn=self.ffn_dim_multiplier,
n_head=self.num_heads,
n_layers=self.num_layers,
n_output=self.num_outputs,
cardinalities=self.cardinalities,
kernel_sizes=self.kernel_sizes,
dist_enc=self.distance_encoding,
pre_ln=self.pre_layer_norm,
dropout=self.dropout,
temperature=self.temperature,
)
copy_parameters(trained_network, prediction_network)
return RepresentableBlockPredictor(
input_transform=transformation,
prediction_net=prediction_network,
batch_size=self.trainer.batch_size,
freq=self.freq,
prediction_length=self.prediction_length,
ctx=self.trainer.ctx,
forecast_generator=QuantileForecastGenerator(
quantiles=[str(q) for q in prediction_network.quantiles], ),
)
def create_predictor(
self, transformation: Transformation, trained_network: HybridBlock
) -> Predictor:
prediction_network = TransformerPredictionNetwork(
encoder=self.encoder,
decoder=self.decoder,
history_length=self.history_length,
context_length=self.context_length,
prediction_length=self.prediction_length,
distr_output=self.distr_output,
cardinality=self.cardinality,
embedding_dimension=self.embedding_dimension,
lags_seq=self.lags_seq,
scaling=True,
num_parallel_samples=self.num_parallel_samples,
)
copy_parameters(trained_network, prediction_network)
return RepresentableBlockPredictor(
input_transform=transformation,
prediction_net=prediction_network,
batch_size=self.trainer.batch_size,
freq=self.freq,
prediction_length=self.prediction_length,
ctx=self.trainer.ctx,
)
def deserialize(
cls,
path: Path,
ctx: Optional[mx.Context] = None) -> "NBEATSEnsemblePredictor":
# deserialize constructor parameters
with (path / "parameters.json").open("r") as fp:
parameters = load_json(fp.read())
# basically save each predictor in its own sub-folder
num_predictors = parameters["num_predictors"]
num_digits = len(str(num_predictors))
predictors = []
# load all the predictors individually and also make sure not to load anything else by mistake
predictor_locations = [
f"predictor_{str(index).zfill(num_digits)}"
for index in range(num_predictors)
]
# deserialize predictors
for sub_dir in predictor_locations:
predictors.append(
RepresentableBlockPredictor.deserialize(path / sub_dir, ctx))
return NBEATSEnsemblePredictor(
prediction_length=parameters["prediction_length"],
freq=parameters["freq"],
predictors=predictors,
aggregation_method=parameters["aggregation_method"],
)
def create_predictor(
self,
transformation: transform.Transformation,
trained_network: mx.gluon.HybridBlock,
bin_values: np.ndarray,
) -> Predictor:
prediction_network = WaveNetSampler(
num_samples=self.num_eval_samples,
temperature=self.temperature,
**self._get_wavenet_args(bin_values),
)
# copy_parameters(net_source=trained_network, net_dest=prediction_network, ignore_extra=True)
copy_parameters(net_source=trained_network,
net_dest=prediction_network)
return RepresentableBlockPredictor(
input_transform=transformation,
prediction_net=prediction_network,
batch_size=self.trainer.batch_size,
freq=self.freq,
prediction_length=self.prediction_length,
ctx=self.trainer.ctx,
)
def create_predictor(
self, transformation: Transformation,
trained_network: HybridBlock) -> RepresentableBlockPredictor:
prediction_network = TemporalFusionTransformerPredictionNetwork(
context_length=self.context_length,
prediction_length=self.prediction_length,
d_var=self.variable_dim,
d_hidden=self.hidden_dim,
n_head=self.num_heads,
n_output=self.num_outputs,
d_past_feat_dynamic_real=list(
self.past_dynamic_feature_dims.values()),
c_past_feat_dynamic_cat=list(
self.past_dynamic_cardinalities.values()),
d_feat_dynamic_real=[1] * len(self.time_features) +
list(self.dynamic_feature_dims.values()),
c_feat_dynamic_cat=list(self.dynamic_cardinalities.values()),
d_feat_static_real=list(self.static_feature_dims.values()),
c_feat_static_cat=list(self.static_cardinalities.values()),
dropout=self.dropout_rate,
)
copy_parameters(trained_network, prediction_network)
return RepresentableBlockPredictor(
input_transform=transformation,
prediction_net=prediction_network,
batch_size=self.trainer.batch_size,
freq=self.freq,
prediction_length=self.prediction_length,
ctx=self.trainer.ctx,
forecast_generator=QuantileForecastGenerator(
quantiles=[str(q) for q in prediction_network.quantiles], ),
)
def create_predictor(
self, transformation: Transformation, trained_network: HybridBlock
) -> Predictor:
prediction_network = DeepStatePredictionNetwork(
num_sample_paths=self.num_sample_paths,
num_layers=self.num_layers,
num_cells=self.num_cells,
cell_type=self.cell_type,
past_length=self.past_length,
prediction_length=self.prediction_length,
issm=self.issm,
dropout_rate=self.dropout_rate,
cardinality=self.cardinality,
embedding_dimension=self.embedding_dimension,
scaling=self.scaling,
params=trained_network.collect_params(),
)
copy_parameters(trained_network, prediction_network)
return RepresentableBlockPredictor(
input_transform=transformation,
prediction_net=prediction_network,
batch_size=self.trainer.batch_size,
freq=self.freq,
prediction_length=self.prediction_length,
ctx=self.trainer.ctx,
)
def create_predictor(
self,
transformation: Transformation,
trained_network: ForkingSeq2SeqNetworkBase,
) -> Predictor:
# this is specific to quantile output
quantile_strs = [
Quantile.from_float(quantile).name
for quantile in self.quantile_output.quantiles
]
prediction_network = ForkingSeq2SeqPredictionNetwork(
encoder=trained_network.encoder,
enc2dec=trained_network.enc2dec,
decoder=trained_network.decoder,
quantile_output=trained_network.quantile_output,
context_length=self.context_length,
cardinality=self.cardinality,
embedding_dimension=self.embedding_dimension,
scaling=self.scaling,
dtype=self.dtype,
)
copy_parameters(trained_network, prediction_network)
return RepresentableBlockPredictor(
input_transform=transformation,
prediction_net=prediction_network,
batch_size=self.trainer.batch_size,
freq=self.freq,
prediction_length=self.prediction_length,
ctx=self.trainer.ctx,
forecast_generator=QuantileForecastGenerator(quantile_strs),
)
def create_predictor(self, transformation: Transformation,
trained_network: HybridBlock) -> Predictor:
prediction_network = DeepARPredictionNetwork(
num_parallel_samples=self.num_parallel_samples,
num_layers=self.num_layers,
num_cells=self.num_cells,
cell_type=self.cell_type,
history_length=self.history_length,
context_length=self.context_length,
prediction_length=self.prediction_length,
distr_output=self.distr_output,
dropoutcell_type=self.dropoutcell_type,
dropout_rate=self.dropout_rate,
cardinality=self.cardinality,
embedding_dimension=self.embedding_dimension,
lags_seq=self.lags_seq,
scaling=self.scaling,
dtype=self.dtype,
)
copy_parameters(trained_network, prediction_network)
return RepresentableBlockPredictor(
input_transform=transformation,
prediction_net=prediction_network,
batch_size=self.trainer.batch_size,
freq=self.freq,
prediction_length=self.prediction_length,
ctx=self.trainer.ctx,
dtype=self.dtype,
)
def create_predictor(
self,
transformation: transform.Transformation,
trained_network: mx.gluon.HybridBlock,
bin_values: np.ndarray,
) -> Predictor:
prediction_network = WaveNetSampler(
num_samples=self.num_parallel_samples,
temperature=self.temperature,
**self._get_wavenet_args(bin_values),
)
# The lookup layer is specific to the sampling network here
# we make sure it is initialized.
prediction_network.initialize()
copy_parameters(
net_source=trained_network,
net_dest=prediction_network,
allow_missing=True,
)
return RepresentableBlockPredictor(
input_transform=transformation,
prediction_net=prediction_network,
batch_size=self.trainer.batch_size,
freq=self.freq,
prediction_length=self.prediction_length,
ctx=self.trainer.ctx,
)
def create_predictor(self, transformation: Transformation,
trained_network: HybridBlock) -> Predictor:
prediction_network = LSTNetPredict(
num_series=self.num_series,
channels=self.channels,
kernel_size=self.kernel_size,
rnn_cell_type=self.rnn_cell_type,
rnn_num_layers=self.rnn_num_layers,
skip_rnn_cell_type=self.skip_rnn_cell_type,
skip_rnn_num_layers=self.skip_rnn_num_layers,
skip_size=self.skip_size,
ar_window=self.ar_window,
context_length=self.context_length,
lead_time=self.lead_time,
prediction_length=self.prediction_length,
dropout_rate=self.dropout_rate,
output_activation=self.output_activation,
scaling=self.scaling,
dtype=self.dtype,
)
copy_parameters(trained_network, prediction_network)
return RepresentableBlockPredictor(
input_transform=transformation,
prediction_net=prediction_network,
batch_size=self.trainer.batch_size,
freq=self.freq,
prediction_length=self.prediction_length,
lead_time=self.lead_time,
ctx=self.trainer.ctx,
dtype=self.dtype,
)
def create_predictor(
self,
transformation: transform.Transformation,
trained_network: Seq2SeqTrainingNetwork,
) -> Predictor:
# todo: this is specific to quantile output
quantile_strs = [
Quantile.from_float(quantile).name for quantile in self.quantiles
]
prediction_network = Seq2SeqPredictionNetwork(
embedder=trained_network.embedder,
scaler=trained_network.scaler,
encoder=trained_network.encoder,
enc2dec=trained_network.enc2dec,
decoder=trained_network.decoder,
quantile_output=trained_network.quantile_output,
)
copy_parameters(trained_network, prediction_network)
return RepresentableBlockPredictor(
input_transform=transformation,
prediction_net=prediction_network,
batch_size=self.trainer.batch_size,
freq=self.freq,
prediction_length=self.prediction_length,
ctx=self.trainer.ctx,
forecast_generator=QuantileForecastGenerator(quantile_strs),
)
def create_predictor(self, transformation: Transformation,
trained_network: HybridBlock) -> Predictor:
prediction_network = GaussianProcessPredictionNetwork(
prediction_length=self.prediction_length,
context_length=self.context_length,
cardinality=self.cardinality,
num_samples=self.num_eval_samples,
params=trained_network.collect_params(),
kernel_output=self.kernel_output,
params_scaling=self.params_scaling,
ctx=self.trainer.ctx,
float_type=self.float_type,
max_iter_jitter=self.max_iter_jitter,
jitter_method=self.jitter_method,
sample_noise=self.sample_noise,
)
copy_parameters(net_source=trained_network,
net_dest=prediction_network)
return RepresentableBlockPredictor(
input_transform=transformation,
prediction_net=prediction_network,
batch_size=self.trainer.batch_size,
freq=self.freq,
prediction_length=self.prediction_length,
ctx=self.trainer.ctx,
float_type=self.float_type,
)
def create_predictor(
self,
transformation: Transformation,
trained_network: ForkingSeq2SeqTrainingNetwork,
) -> Predictor:
# todo: this is specific to quantile output
quantile_strs = [
parse_quantile_input(q)[1] for q in self.quantile_output.quantiles
]
prediction_network = ForkingSeq2SeqPredictionNetwork(
encoder=trained_network.encoder,
enc2dec=trained_network.enc2dec,
decoder=trained_network.decoder,
quantile_output=trained_network.quantile_output,
)
copy_parameters(trained_network, prediction_network)
return RepresentableBlockPredictor(
input_transform=transformation,
prediction_net=prediction_network,
batch_size=self.trainer.batch_size,
freq=self.freq,
prediction_length=self.prediction_length,
ctx=self.trainer.ctx,
forecast_cls_name=QuantileForecast.__name__,
forecast_kwargs=dict(forecast_keys=quantile_strs),
)
def create_predictor(self, transformation, trained_network):
if self.sampling is True:
prediction_network = SimpleFeedForwardSamplingNetwork(
num_hidden_dimensions=self.num_hidden_dimensions,
prediction_length=self.prediction_length,
context_length=self.context_length,
distr_output=self.distr_output,
batch_normalization=self.batch_normalization,
mean_scaling=self.mean_scaling,
params=trained_network.collect_params(),
num_parallel_samples=self.num_parallel_samples,
)
return RepresentableBlockPredictor(
input_transform=transformation,
prediction_net=prediction_network,
batch_size=self.trainer.batch_size,
freq=self.freq,
prediction_length=self.prediction_length,
ctx=self.trainer.ctx,
)
else:
prediction_network = SimpleFeedForwardDistributionNetwork(
num_hidden_dimensions=self.num_hidden_dimensions,
prediction_length=self.prediction_length,
context_length=self.context_length,
distr_output=self.distr_output,
batch_normalization=self.batch_normalization,
mean_scaling=self.mean_scaling,
params=trained_network.collect_params(),
num_parallel_samples=self.num_parallel_samples,
)
return RepresentableBlockPredictor(
input_transform=transformation,
prediction_net=prediction_network,
batch_size=self.trainer.batch_size,
forecast_generator=DistributionForecastGenerator(
self.distr_output),
freq=self.freq,
prediction_length=self.prediction_length,
ctx=self.trainer.ctx,
)
def create_predictor(self, transformation: Transformation,
trained_network: HybridBlock) -> Predictor:
prediction_network = MyPredNetwork1(
prediction_length=self.prediction_length, num_cells=self.num_cells)
copy_parameters(trained_network, prediction_network)
return RepresentableBlockPredictor(
input_transform=transformation,
prediction_net=prediction_network,
batch_size=self.trainer.batch_size,
freq=self.freq,
prediction_length=self.prediction_length,
ctx=self.trainer.ctx)
def create_predictor(
self,
transformation: Transformation,
trained_network: ForkingSeq2SeqNetworkBase,
) -> Predictor:
quantile_strs = (
[
Quantile.from_float(quantile).name
for quantile in self.quantile_output.quantiles
]
if self.quantile_output is not None
else None
)
prediction_network_class = (
ForkingSeq2SeqPredictionNetwork
if self.quantile_output is not None
else ForkingSeq2SeqDistributionPredictionNetwork
)
prediction_network = prediction_network_class(
encoder=trained_network.encoder,
enc2dec=trained_network.enc2dec,
decoder=trained_network.decoder,
quantile_output=trained_network.quantile_output,
distr_output=trained_network.distr_output,
context_length=self.context_length,
num_forking=self.num_forking,
cardinality=self.cardinality,
embedding_dimension=self.embedding_dimension,
scaling=self.scaling,
dtype=self.dtype,
)
copy_parameters(trained_network, prediction_network)
return RepresentableBlockPredictor(
input_transform=transformation,
prediction_net=prediction_network,
batch_size=self.trainer.batch_size,
freq=self.freq,
prediction_length=self.prediction_length,
ctx=self.trainer.ctx,
forecast_generator=(
QuantileForecastGenerator(quantile_strs)
if quantile_strs is not None
else DistributionForecastGenerator(self.distr_output)
),
)
def create_predictor(self, transformation: Transformation,
trained_network: HybridBlock) -> Predictor:
prediction_network = CustomSimpleFeedForwardPredNetwork(
prediction_length=self.prediction_length,
distr_output=self.distr_output,
distr_output_type=self.distr_output_type,
num_cells=self.num_cells,
num_sample_paths=self.num_sample_paths,
alpha=self.alpha)
copy_parameters(trained_network, prediction_network)
return RepresentableBlockPredictor(
input_transform=transformation,
prediction_net=prediction_network,
batch_size=self.trainer.batch_size,
freq=self.freq,
prediction_length=self.prediction_length,
ctx=self.trainer.ctx,
)
def create_predictor(self, transformation: Transformation,
trained_network: HybridBlock) -> Predictor:
prediction_network = SimpleFeedForwardPredictionNetwork(
num_hidden_dimensions=self.num_hidden_dimensions,
prediction_length=self.prediction_length,
context_length=self.context_length,
distr_output=self.distr_output,
batch_normalization=self.batch_normalization,
mean_scaling=self.mean_scaling,
params=trained_network.collect_params(),
num_parallel_samples=self.num_parallel_samples,
)
return RepresentableBlockPredictor(
input_transform=transformation,
prediction_net=prediction_network,
batch_size=self.trainer.batch_size,
freq=self.freq,
prediction_length=self.prediction_length,
ctx=self.trainer.ctx,
)
def create_predictor(
self,
transformation: Transformation,
trained_network: gluon.HybridBlock,
) -> Predictor:
prediction_network = MyPredNetwork(
prediction_length=self.prediction_length,
cells=self.cells,
act_type=self.act_type,
)
copy_parameters(trained_network, prediction_network)
return RepresentableBlockPredictor(
input_transform=transformation,
prediction_net=prediction_network,
batch_size=self.trainer.batch_size,
freq=self.freq,
prediction_length=self.prediction_length,
ctx=self.trainer.ctx,
)
def create_predictor(
self,
transformation: Transformation,
trained_network: DeepFactorTrainingNetwork,
) -> Predictor:
prediction_net = DeepFactorPredictionNetwork(
embedder=trained_network.embedder,
global_model=trained_network.global_factor,
local_model=trained_network.local_model,
prediction_len=self.prediction_length,
num_sample_paths=self.num_sample_paths,
params=trained_network.collect_params(),
)
return RepresentableBlockPredictor(
input_transform=transformation,
prediction_net=prediction_net,
batch_size=self.trainer.batch_size,
freq=self.freq,
prediction_length=self.prediction_length,
ctx=self.trainer.ctx,
)
def create_predictor(
self,
transformation: Transformation,
trained_network: CanonicalTrainingNetwork,
) -> Predictor:
prediction_net = CanonicalPredictionNetwork(
embedder=trained_network.embedder,
model=trained_network.model,
distr_output=trained_network.distr_output,
is_sequential=trained_network.is_sequential,
prediction_len=self.prediction_length,
num_sample_paths=self.num_sample_paths,
params=trained_network.collect_params(),
)
return RepresentableBlockPredictor(
input_transform=transformation,
prediction_net=prediction_net,
batch_size=self.trainer.batch_size,
freq=self.freq,
prediction_length=self.prediction_length,
ctx=self.trainer.ctx,
)
def create_predictor(self, transformation: Transformation,
trained_network: HybridBlock) -> Predictor:
prediction_network = NBEATSPredictionNetwork(
prediction_length=self.prediction_length,
context_length=self.context_length,
num_stacks=self.num_stacks,
widths=self.widths,
num_blocks=self.num_blocks,
num_block_layers=self.num_block_layers,
expansion_coefficient_lengths=self.expansion_coefficient_lengths,
sharing=self.sharing,
stack_types=self.stack_types,
params=trained_network.collect_params(),
)
return RepresentableBlockPredictor(
input_transform=transformation,
prediction_net=prediction_network,
batch_size=self.trainer.batch_size,
freq=self.freq,
prediction_length=self.prediction_length,
ctx=self.trainer.ctx,
)
def init_model():
epochs = None
context = 'cpu'
if args.epochs is not None:
epochs = args.epochs
if args.gpu:
context = 'gpu'
predictor = None
if args.train:
my_trainer = Trainer(
ctx=context
) # TODO: Find a way to make it such that we do not set epoch when there is no need to
estimator = DeepAREstimator(freq="5min",
prediction_length=args.prediction,
trainer=my_trainer)
predictor = estimator.train(training_data=training_data)
predictor.serialize(Path("models/"))
else:
# predictor = Predictor.deserialize(Path("models/"))
predictor = RepresentableBlockPredictor.deserialize(Path("models/"))
predictor.ctx = mx.Context('cpu')
return predictor
