def create_predictor(
self,
transformation: Transformation,
trained_network: CanonicalTrainingNetwork,
) -> Predictor:
prediction_splitter = self._create_instance_splitter("test")
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_parallel_samples=self.num_parallel_samples,
params=trained_network.collect_params(),
)
return RepresentableBlockPredictor(
input_transform=transformation + prediction_splitter,
prediction_net=prediction_net,
batch_size=self.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_splitter = self._create_instance_splitter("test")
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(),
scale=self.scale,
)
return RepresentableBlockPredictor(
input_transform=transformation + prediction_splitter,
prediction_net=prediction_network,
batch_size=self.batch_size,
freq=self.freq,
prediction_length=self.prediction_length,
ctx=self.trainer.ctx,
)
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_splitter = self._create_instance_splitter("test")
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_splitter,
prediction_net=prediction_network,
batch_size=self.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) -> 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.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_splitter = self._create_instance_splitter("test")
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_splitter,
prediction_net=prediction_network,
batch_size=self.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 = 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.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,
) -> Predictor:
prediction_splitter = self._create_instance_splitter("test")
prediction_network = WaveNetSampler(
num_samples=self.num_parallel_samples,
temperature=self.temperature,
**self._get_wavenet_args(),
)
# 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_splitter,
prediction_net=prediction_network,
batch_size=self.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_splitter = self._create_instance_splitter("test")
prediction_network = DeepStatePredictionNetwork(
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,
num_parallel_samples=self.num_parallel_samples,
noise_std_bounds=self.noise_std_bounds,
prior_cov_bounds=self.prior_cov_bounds,
innovation_bounds=self.innovation_bounds,
params=trained_network.collect_params(),
)
copy_parameters(trained_network, prediction_network)
return RepresentableBlockPredictor(
input_transform=transformation + prediction_splitter,
prediction_net=prediction_network,
batch_size=self.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,
rnn_num_cells=self.rnn_num_cells,
skip_rnn_cell_type=self.skip_rnn_cell_type,
skip_rnn_num_layers=self.skip_rnn_num_layers,
skip_rnn_num_cells=self.skip_rnn_num_cells,
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.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: Transformation, trained_network: HybridBlock
) -> Predictor:
prediction_splitter = self._create_instance_splitter("test")
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_splitter,
prediction_net=prediction_network,
batch_size=self.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) -> Predictor:
prediction_network = GaussianProcessPredictionNetwork(
prediction_length=self.prediction_length,
context_length=self.context_length,
cardinality=self.cardinality,
num_parallel_samples=self.num_parallel_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.batch_size,
freq=self.freq,
prediction_length=self.prediction_length,
ctx=self.trainer.ctx,
dtype=self.float_type,
)
def create_predictor(self, transformation, trained_network):
prediction_splitter = self._create_instance_splitter("test")
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_splitter,
prediction_net=prediction_network,
batch_size=self.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_splitter,
prediction_net=prediction_network,
batch_size=self.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: 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_splitter = self._create_instance_splitter("test")
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,
scaling_decoder_dynamic_feature=self.scaling_decoder_dynamic_feature,
dtype=self.dtype,
)
copy_parameters(trained_network, prediction_network)
return RepresentableBlockPredictor(
input_transform=transformation + prediction_splitter,
prediction_net=prediction_network,
batch_size=self.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
) -> RepresentableBlockPredictor:
prediction_splitter = self._create_instance_splitter("test")
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=_default_feat_args(
list(self.past_dynamic_feature_dims.values())
),
c_past_feat_dynamic_cat=_default_feat_args(
list(self.past_dynamic_cardinalities.values())
),
d_feat_dynamic_real=_default_feat_args(
[1] * len(self.time_features)
+ list(self.dynamic_feature_dims.values())
),
c_feat_dynamic_cat=_default_feat_args(
list(self.dynamic_cardinalities.values())
),
d_feat_static_real=_default_feat_args(
list(self.static_feature_dims.values()),
),
c_feat_static_cat=_default_feat_args(
list(self.static_cardinalities.values()),
),
dropout=self.dropout_rate,
)
copy_parameters(trained_network, prediction_network)
return RepresentableBlockPredictor(
input_transform=transformation + prediction_splitter,
prediction_net=prediction_network,
batch_size=self.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.output.quantiles
],
),
)
def deserialize(cls,
path: Path,
ctx: Optional[mx.Context] = None,
**kwargs) -> "NBEATSEnsemblePredictor":
"""
Load a serialized NBEATSEnsemblePredictor from the given path.
Parameters
----------
path
Path to the serialized files predictor.
ctx
Optional mxnet context parameter to be used with the predictor.
If nothing is passed will use the GPU if available and CPU
otherwise.
"""
# 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: 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_model,
local_model=trained_network.local_model,
prediction_len=self.prediction_length,
num_parallel_samples=self.num_parallel_samples,
params=trained_network.collect_params(),
)
return RepresentableBlockPredictor(
input_transform=transformation,
prediction_net=prediction_net,
batch_size=self.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_splitter = self._create_instance_splitter("test")
prediction_network = DeepVARHierarchicalPredictionNetwork(
M=self.M,
A=self.A,
assert_reconciliation=self.assert_reconciliation,
coherent_pred_samples=self.coherent_pred_samples,
reconciliation_tol=self.reconciliation_tol,
target_dim=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,
distr_output=self.distr_output,
dropout_rate=self.dropout_rate,
cardinality=self.cardinality,
embedding_dimension=self.embedding_dimension,
lags_seq=self.lags_seq,
scaling=self.scaling,
)
copy_parameters(trained_network, prediction_network)
return RepresentableBlockPredictor(
input_transform=transformation + prediction_splitter,
prediction_net=prediction_network,
batch_size=self.batch_size,
freq=self.freq,
prediction_length=self.prediction_length,
ctx=self.trainer.ctx,
output_transform=self.output_transform,
)
