def __init__(
self,
freq: str,
prediction_length: int,
trainer: Trainer = Trainer(),
num_hidden_dimensions: Optional[List[int]] = None,
context_length: Optional[int] = None,
distr_output: DistributionOutput = StudentTOutput(),
batch_normalization: bool = False,
mean_scaling: bool = True,
num_parallel_samples: int = 100,
) -> None:
"""
Defines an estimator. All parameters should be serializable.
"""
super().__init__(trainer=trainer)
self.num_hidden_dimensions = (num_hidden_dimensions
if num_hidden_dimensions is not None else
list([40, 40]))
self.prediction_length = prediction_length
self.context_length = (context_length if context_length is not None
else prediction_length)
self.freq = freq
self.distr_output = distr_output
self.batch_normalization = batch_normalization
self.mean_scaling = mean_scaling
self.num_parallel_samples = num_parallel_samples
self.train_sampler = ExpectedNumInstanceSampler(
num_instances=1, min_future=prediction_length)
self.validation_sampler = ValidationSplitSampler(
min_future=prediction_length)
def test_deepvar(
distr_output, num_batches_per_epoch, Estimator, use_marginal_transformation,
):
estimator = Estimator(
input_size=44,
num_cells=20,
num_layers=1,
dropout_rate=0.0,
pick_incomplete=True,
target_dim=target_dim,
prediction_length=metadata.prediction_length,
freq=metadata.freq,
distr_output=distr_output,
scaling=False,
use_marginal_transformation=use_marginal_transformation,
trainer=Trainer(
epochs=1,
batch_size=8,
learning_rate=1e-10,
num_batches_per_epoch=num_batches_per_epoch,
),
)
agg_metrics, _ = backtest_metrics(
train_dataset=dataset.train,
test_dataset=dataset.test,
forecaster=estimator,
evaluator=MultivariateEvaluator(
quantiles=(0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9)
),
)
assert agg_metrics["ND"] < 1.5
def __init__(
self,
freq: str,
prediction_length: int,
context_length: Optional[int] = None,
dropout_rate: float = 0.1,
embed_dim: int = 32,
num_heads: int = 4,
num_outputs: int = 3,
variable_dim: Optional[int] = None,
time_features: List[TimeFeature] = [],
static_cardinalities: Dict[str, int] = {},
dynamic_cardinalities: Dict[str, int] = {},
static_feature_dims: Dict[str, int] = {},
dynamic_feature_dims: Dict[str, int] = {},
past_dynamic_features: List[str] = [],
trainer: Trainer = Trainer(),
) -> None:
super().__init__(trainer=trainer)
self.freq = freq
self.prediction_length = prediction_length
self.context_length = context_length or prediction_length
# MultiheadAttention
self.dropout_rate = dropout_rate
self.embed_dim = embed_dim
self.num_heads = num_heads
self.num_outputs = num_outputs
self.variable_dim = variable_dim or embed_dim
if not time_features:
self.time_features = time_features_from_frequency_str(self.freq)
else:
self.time_features = time_features
self.static_cardinalities = static_cardinalities
self.dynamic_cardinalities = dynamic_cardinalities
self.static_feature_dims = static_feature_dims
self.dynamic_feature_dims = dynamic_feature_dims
self.past_dynamic_features = past_dynamic_features
self.past_dynamic_cardinalities = {}
self.past_dynamic_feature_dims = {}
for name in self.past_dynamic_features:
if name in self.dynamic_cardinalities:
self.past_dynamic_cardinalities[
name] = self.dynamic_cardinalities.pop(name)
elif name in self.dynamic_feature_dims:
self.past_dynamic_feature_dims[
name] = self.dynamic_feature_dims.pop(name)
else:
raise ValueError(
f"Feature name {name} is not provided in feature dicts")
self.train_sampler = ExpectedNumInstanceSampler(
num_instances=1.0, min_future=prediction_length)
self.validation_sampler = ValidationSplitSampler(
min_future=prediction_length)
def test_training_with_implicit_quantile_output():
dataset = get_dataset("constant")
metadata = dataset.metadata
deepar_estimator = DeepAREstimator(
distr_output=ImplicitQuantileOutput(output_domain="Real"),
freq=metadata.freq,
prediction_length=metadata.prediction_length,
trainer=Trainer(
device="cpu",
epochs=5,
learning_rate=1e-3,
num_batches_per_epoch=3,
batch_size=256,
),
input_size=15,
)
deepar_predictor = deepar_estimator.train(dataset.train, num_workers=1)
forecast_it, ts_it = make_evaluation_predictions(
dataset=dataset.test, # test dataset
predictor=deepar_predictor, # predictor
num_samples=100, # number of sample paths we want for evaluation
)
forecasts = list(forecast_it)
tss = list(ts_it)
evaluator = Evaluator(num_workers=0)
agg_metrics, item_metrics = evaluator(iter(tss),
iter(forecasts),
num_series=len(dataset.test))
assert agg_metrics["MSE"] > 0
def __init__(
self,
input_size: int,
freq: str,
prediction_length: int,
context_length: Optional[int] = None,
trainer: Trainer = Trainer(),
dropout_rate: float = 0.1,
cardinality: Optional[List[int]] = None,
embedding_dimension: List[int] = [20],
distr_output: DistributionOutput = StudentTOutput(),
d_model: int = 32,
dim_feedforward_scale: int = 4,
act_type: str = "gelu",
num_heads: int = 8,
num_encoder_layers: int = 3,
num_decoder_layers: int = 3,
scaling: bool = True,
lags_seq: Optional[List[int]] = None,
time_features: Optional[List[TimeFeature]] = None,
use_feat_dynamic_real: bool = False,
use_feat_static_cat: bool = False,
use_feat_static_real: bool = False,
num_parallel_samples: int = 100,
) -> None:
super().__init__(trainer=trainer)
self.input_size = input_size
self.freq = freq
self.prediction_length = prediction_length
self.context_length = (context_length if context_length is not None
else prediction_length)
self.distr_output = distr_output
self.dropout_rate = dropout_rate
self.use_feat_dynamic_real = use_feat_dynamic_real
self.use_feat_static_cat = use_feat_static_cat
self.use_feat_static_real = use_feat_static_real
self.cardinality = cardinality if use_feat_static_cat else [1]
self.embedding_dimension = embedding_dimension
self.num_parallel_samples = num_parallel_samples
self.lags_seq = (lags_seq if lags_seq is not None else
lags_for_fourier_time_features_from_frequency(
freq_str=freq))
self.time_features = (time_features if time_features is not None else
fourier_time_features_from_frequency(self.freq))
self.history_length = self.context_length + max(self.lags_seq)
self.scaling = scaling
self.d_model = d_model
self.num_heads = num_heads
self.act_type = act_type
self.dim_feedforward_scale = dim_feedforward_scale
self.num_encoder_layers = num_encoder_layers
self.num_decoder_layers = num_decoder_layers
self.train_sampler = ExpectedNumInstanceSampler(
num_instances=1.0, min_future=prediction_length)
self.validation_sampler = ValidationSplitSampler(
min_future=prediction_length)
def __init__(
self,
freq: str,
prediction_length: int,
input_size: int,
trainer: Trainer = Trainer(),
context_length: Optional[int] = None,
num_layers: int = 3,
num_cells: int = 40,
cell_type: str = "LSTM",
dropout_rate: float = 0.1,
use_feat_dynamic_real: bool = False,
use_feat_dynamic_cat: bool = False,
use_feat_static_cat: bool = False,
use_feat_static_real: bool = False,
cardinality: Optional[List[int]] = None,
embedding_dimension: Optional[List[int]] = None,
distr_output: DistributionOutput = StudentTOutput(),
scaling: bool = True,
lags_seq: Optional[List[int]] = None,
time_features: Optional[List[TimeFeature]] = None,
num_parallel_samples: int = 100,
dtype: np.dtype = np.float32,
) -> None:
super().__init__(trainer=trainer)
self.freq = freq
self.context_length = (context_length if context_length is not None
else prediction_length)
self.prediction_length = prediction_length
self.distr_output = distr_output
self.distr_output.dtype = dtype
self.input_size = input_size
self.num_layers = num_layers
self.num_cells = num_cells
self.cell_type = cell_type
self.dropout_rate = dropout_rate
self.use_feat_dynamic_real = use_feat_dynamic_real
self.use_feat_dynamic_cat = use_feat_dynamic_cat
self.use_feat_static_cat = use_feat_static_cat
self.use_feat_static_real = use_feat_static_real
self.cardinality = (cardinality
if cardinality and use_feat_static_cat else [1])
self.embedding_dimension = (
embedding_dimension if embedding_dimension is not None else
[min(50, (cat + 1) // 2) for cat in self.cardinality])
self.scaling = scaling
self.lags_seq = (
# lags_seq if lags_seq is not None else get_lags_for_frequency(freq_str=freq)
lags_seq if lags_seq is not None else get_lags_for_frequency(
freq_str=freq, num_lags=0))
self.time_features = (time_features if time_features is not None else
time_features_from_frequency_str(self.freq))
# self.history_length = self.context_length + max(self.lags_seq)
self.history_length = self.context_length
self.num_parallel_samples = num_parallel_samples
def __init__(
self,
freq: str,
prediction_length: int,
meta_context_length: Optional[List[int]] = None,
meta_loss_function: Optional[List[str]] = None,
meta_bagging_size: int = 10,
trainer: Trainer = Trainer(),
num_stacks: int = 30,
widths: Optional[List[int]] = None,
num_blocks: Optional[List[int]] = None,
num_block_layers: Optional[List[int]] = None,
expansion_coefficient_lengths: Optional[List[int]] = None,
sharing: Optional[List[bool]] = None,
stack_types: Optional[List[str]] = None,
**kwargs,
) -> None:
super().__init__()
assert (prediction_length >
0), "The value of `prediction_length` should be > 0"
self.freq = freq
self.prediction_length = prediction_length
assert meta_loss_function is None or all(
[
loss_function in VALID_LOSS_FUNCTIONS
for loss_function in meta_loss_function
]
), f"Each loss function has to be one of the following: {VALID_LOSS_FUNCTIONS}."
assert meta_context_length is None or all([
context_length > 0 for context_length in meta_context_length
]), "The value of each `context_length` should be > 0"
assert (meta_bagging_size is None or meta_bagging_size > 0
), "The value of each `context_length` should be > 0"
self.meta_context_length = (
meta_context_length if meta_context_length is not None else
[multiplier * prediction_length for multiplier in range(2, 8)])
self.meta_loss_function = (meta_loss_function if meta_loss_function
is not None else VALID_LOSS_FUNCTIONS)
self.meta_bagging_size = meta_bagging_size
# The following arguments are validated in the NBEATSEstimator:
self.trainer = trainer
print(f"TRAINER:{str(trainer)}")
self.num_stacks = num_stacks
self.widths = widths
self.num_blocks = num_blocks
self.num_block_layers = num_block_layers
self.expansion_coefficient_lengths = expansion_coefficient_lengths
self.sharing = sharing
self.stack_types = stack_types
# Actually instantiate the different models
self.estimators = self._estimator_factory(**kwargs)
def test_lstnet(skip_size, ar_window, horizon, prediction_length):
estimator = LSTNetEstimator(
skip_size=skip_size,
ar_window=ar_window,
num_series=NUM_SERIES,
channels=6,
kernel_size=2,
context_length=4,
freq=freq,
horizon=horizon,
prediction_length=prediction_length,
trainer=Trainer(
epochs=1,
batch_size=2,
learning_rate=0.01,
),
)
predictor = estimator.train(dataset.train)
forecast_it, ts_it = make_evaluation_predictions(dataset=dataset.test,
predictor=predictor,
num_samples=NUM_SAMPLES)
forecasts = list(forecast_it)
tss = list(ts_it)
assert len(forecasts) == len(tss) == len(dataset.test)
test_ds = dataset.test.list_data[0]
for fct in forecasts:
assert fct.freq == freq
if estimator.horizon:
assert fct.samples.shape == (NUM_SAMPLES, 1, NUM_SERIES)
else:
assert fct.samples.shape == (
NUM_SAMPLES,
prediction_length,
NUM_SERIES,
)
assert (fct.start_date == pd.date_range(
start=str(test_ds["start"]),
periods=test_ds["target"].shape[1], # number of test periods
freq=freq,
closed="right",
)[-(horizon or prediction_length)])
evaluator = MultivariateEvaluator(
quantiles=[0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9])
agg_metrics, item_metrics = evaluator(iter(tss),
iter(forecasts),
num_series=len(dataset.test))
assert agg_metrics["ND"] < 0.21
def __init__(
self,
freq: str,
prediction_length: Optional[int],
context_length: int,
num_series: int,
ar_window: int = 24,
skip_size: int = 24,
channels: int = 100,
kernel_size: int = 6,
horizon: Optional[int] = None,
trainer: Trainer = Trainer(),
dropout_rate: Optional[float] = 0.2,
output_activation: Optional[str] = None,
rnn_cell_type: str = "GRU",
rnn_num_cells: int = 100,
skip_rnn_cell_type: str = "GRU",
skip_rnn_num_cells: int = 5,
scaling: bool = True,
dtype: np.dtype = np.float32,
):
super().__init__(trainer, dtype=dtype)
self.freq = freq
self.num_series = num_series
self.skip_size = skip_size
self.ar_window = ar_window
self.horizon = horizon
self.prediction_length = prediction_length
self.future_length = horizon if horizon is not None else prediction_length
self.context_length = context_length
self.channels = channels
self.kernel_size = kernel_size
self.dropout_rate = dropout_rate
self.output_activation = output_activation
self.rnn_cell_type = rnn_cell_type
self.rnn_num_cells = rnn_num_cells
self.skip_rnn_cell_type = skip_rnn_cell_type
self.skip_rnn_num_cells = skip_rnn_num_cells
self.scaling = scaling
self.train_sampler = ExpectedNumInstanceSampler(
num_instances=1.0, min_future=self.future_length
)
self.validation_sampler = ValidationSplitSampler(min_future=self.future_length)
self.dtype = dtype
def __init__(
self,
prediction_length: int,
freq: int,
trainer: Trainer = Trainer(),
context_length: Optional[int] = None,
num_parallel_samples: int = 100,
) -> None:
"""
Defines an estimator. All parameters should be serializable.
"""
super().__init__(trainer=trainer)
self.num_parallel_samples = num_parallel_samples
self.freq = freq
self.prediction_length = prediction_length
self.context_length = (context_length if context_length is not None
else prediction_length)
def test_distribution():
"""
Makes sure additional tensors can be accessed and have expected shapes
"""
prediction_length = ds_info.prediction_length
estimator = DeepAREstimator(
freq=freq,
prediction_length=prediction_length,
input_size=15,
trainer=Trainer(epochs=1, num_batches_per_epoch=1),
distr_output=StudentTOutput(),
)
train_output = estimator.train_model(train_ds)
# todo adapt loader to anomaly detection use-case
batch_size = 2
num_samples = 3
training_data_loader = TrainDataLoader(
train_ds,
transform=train_output.transformation
+ estimator.create_instance_splitter("training"),
batch_size=batch_size,
num_batches_per_epoch=estimator.trainer.num_batches_per_epoch,
stack_fn=batchify,
)
seq_len = 2 * ds_info.prediction_length
for data_entry in islice(training_data_loader, 1):
input_names = get_module_forward_input_names(train_output.trained_net)
distr = train_output.trained_net.distribution(
*[data_entry[k] for k in input_names]
)
assert distr.sample((num_samples,)).shape == (
num_samples,
batch_size,
seq_len,
)
def GlounTS():
from pts.dataset import ListDataset
from pts.model.deepar import DeepAREstimator
from pts import Trainer
from pts.dataset import to_pandas
# gluonts crash in my sistem.
#from gluonts.dataset.common import ListDataset
#from gluonts.model.deepar import DeepAREstimator
#from gluonts.trainer import Trainer
training_data = ListDataset([{"start": df.index[0], "target": df.value[:"2015-03-08 23:22:53"]}], freq="5min")
estimator = DeepAREstimator(freq="5min",input_size = 43, prediction_length=forecast_size, trainer=Trainer(epochs=20))
predictor = estimator.train(training_data=training_data)
test_data = ListDataset([{"start": df.index[0], "target": df.value[:"2015-03-08 23:22:53"]}], freq="5min")
GluonTS_prediction = next(predictor.predict(test_data))
GluonTS_mean_yhat = GluonTS_prediction.mean
GluonTS_median_yhat = GluonTS_prediction.median
return GluonTS_mean_yhat.tolist(), GluonTS_median_yhat.tolist(), GluonTS_prediction
def __init__(
self,
input_size: int,
freq: str,
prediction_length: int,
target_dim: int,
trainer: Trainer = Trainer(),
context_length: Optional[int] = None,
num_layers: int = 2,
num_cells: int = 40,
cell_type: str = "LSTM",
num_parallel_samples: int = 100,
dropout_rate: float = 0.1,
use_feat_dynamic_real: bool = False,
use_feat_static_cat: bool = False,
use_feat_static_real: bool = False,
cardinality: Optional[List[int]] = None,
embedding_dimension: Optional[List[int]] = None,
distr_output: Optional[DistributionOutput] = None,
rank: Optional[int] = 5,
scaling: bool = True,
pick_incomplete: bool = False,
lags_seq: Optional[List[int]] = None,
time_features: Optional[List[TimeFeature]] = None,
conditioning_length: int = 200,
use_marginal_transformation=False,
**kwargs,
) -> None:
super().__init__(trainer=trainer, **kwargs)
self.freq = freq
self.context_length = (context_length if context_length is not None
else prediction_length)
if distr_output is not None:
self.distr_output = distr_output
else:
self.distr_output = LowRankMultivariateNormalOutput(dim=target_dim,
rank=rank)
self.input_size = input_size
self.prediction_length = prediction_length
self.target_dim = target_dim
self.num_layers = num_layers
self.num_cells = num_cells
self.cell_type = cell_type
self.num_parallel_samples = num_parallel_samples
self.dropout_rate = dropout_rate
self.use_feat_dynamic_real = use_feat_dynamic_real
self.use_feat_static_cat = use_feat_static_cat
self.use_feat_static_real = use_feat_static_real
self.cardinality = cardinality if cardinality and use_feat_static_cat else [
1
]
self.embedding_dimension = (
embedding_dimension if embedding_dimension is not None else
[min(50, (cat + 1) // 2) for cat in self.cardinality])
self.conditioning_length = conditioning_length
self.use_marginal_transformation = use_marginal_transformation
self.lags_seq = (lags_seq if lags_seq is not None else
lags_for_fourier_time_features_from_frequency(
freq_str=freq))
self.time_features = (time_features if time_features is not None else
fourier_time_features_from_frequency(self.freq))
self.history_length = self.context_length + max(self.lags_seq)
self.pick_incomplete = pick_incomplete
self.scaling = scaling
if self.use_marginal_transformation:
self.output_transform: Optional[
Callable] = cdf_to_gaussian_forward_transform
else:
self.output_transform = None
self.train_sampler = ExpectedNumInstanceSampler(
num_instances=1.0,
min_past=0 if pick_incomplete else self.history_length,
min_future=prediction_length,
)
self.validation_sampler = ValidationSplitSampler(
min_past=0 if pick_incomplete else self.history_length,
min_future=prediction_length,
)
def __init__(
self,
input_size: int,
freq: str,
prediction_length: int,
target_dim: int,
trainer: Trainer = Trainer(),
context_length: Optional[int] = None,
d_model: int = 32,
dim_feedforward_scale: int = 4,
act_type: str = "gelu",
num_heads: int = 8,
num_encoder_layers: int = 3,
num_decoder_layers: int = 3,
num_parallel_samples: int = 100,
dropout_rate: float = 0.1,
use_feat_dynamic_real: bool = False,
flow_type="RealNVP",
n_blocks=3,
hidden_size=100,
n_hidden=2,
conditioning_length: int = 200,
dequantize: bool = False,
scaling: bool = True,
pick_incomplete: bool = False,
lags_seq: Optional[List[int]] = None,
time_features: Optional[List[TimeFeature]] = None,
**kwargs,
) -> None:
super().__init__(trainer=trainer, **kwargs)
self.freq = freq
self.context_length = (context_length if context_length is not None
else prediction_length)
self.input_size = input_size
self.prediction_length = prediction_length
self.target_dim = target_dim
self.d_model = d_model
self.num_heads = num_heads
self.act_type = act_type
self.dim_feedforward_scale = dim_feedforward_scale
self.num_encoder_layers = num_encoder_layers
self.num_decoder_layers = num_decoder_layers
self.num_parallel_samples = num_parallel_samples
self.dropout_rate = dropout_rate
self.use_feat_dynamic_real = use_feat_dynamic_real
self.flow_type = flow_type
self.n_blocks = n_blocks
self.hidden_size = hidden_size
self.n_hidden = n_hidden
self.conditioning_length = conditioning_length
self.dequantize = dequantize
self.lags_seq = (lags_seq if lags_seq is not None else
lags_for_fourier_time_features_from_frequency(
freq_str=freq))
self.time_features = (time_features if time_features is not None else
fourier_time_features_from_frequency(self.freq))
self.history_length = self.context_length + max(self.lags_seq)
self.pick_incomplete = pick_incomplete
self.scaling = scaling
self.train_sampler = ExpectedNumInstanceSampler(
num_instances=1.0,
min_past=0 if pick_incomplete else self.history_length,
min_future=prediction_length,
)
self.validation_sampler = ValidationSplitSampler(
min_past=0 if pick_incomplete else self.history_length,
min_future=prediction_length,
)
def test_instanciation_of_args_proj():
class MockedImplicitQuantileOutput(ImplicitQuantileOutput):
method_calls = 0
@classmethod
def set_args_proj(cls):
super().set_args_proj()
cls.method_calls += 1
dataset = get_dataset("constant")
metadata = dataset.metadata
distr_output = MockedImplicitQuantileOutput(output_domain="Real")
deepar_estimator = DeepAREstimator(
distr_output=distr_output,
freq=metadata.freq,
prediction_length=metadata.prediction_length,
trainer=Trainer(
device="cpu",
epochs=3,
learning_rate=1e-3,
num_batches_per_epoch=1,
batch_size=256,
),
input_size=15,
)
assert distr_output.method_calls == 1
deepar_predictor = deepar_estimator.train(dataset.train, num_workers=1)
# Method should be called when the MockedImplicitQuantileOutput is instanciated,
# and one more time because in_features is different from 1
assert distr_output.method_calls == 2
forecast_it, ts_it = make_evaluation_predictions(
dataset=dataset.test, # test dataset
predictor=deepar_predictor, # predictor
num_samples=100, # number of sample paths we want for evaluation
)
forecasts = list(forecast_it)
tss = list(ts_it)
evaluator = Evaluator(num_workers=0)
agg_metrics, item_metrics = evaluator(iter(tss),
iter(forecasts),
num_series=len(dataset.test))
assert distr_output.method_calls == 2
# Test that the implicit output module is proper reset
new_estimator = DeepAREstimator(
distr_output=MockedImplicitQuantileOutput(output_domain="Real"),
freq=metadata.freq,
prediction_length=metadata.prediction_length,
trainer=Trainer(
device="cpu",
epochs=3,
learning_rate=1e-3,
num_batches_per_epoch=1,
batch_size=256,
),
input_size=15,
)
assert distr_output.method_calls == 3
new_estimator.train(dataset.train, num_workers=1)
assert (
distr_output.method_calls == 3
) # Since in_feature is the same as before, there should be no additional call
df[:100].plot(linewidth=2)
plt.grid(which='both')
plt.show()
training_data = ListDataset([{
"start": df.index[0],
"target": df.value[:"2015-04-05 00:00:00"]
}],
freq="5min")
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
estimator = DeepAREstimator(freq="5min",
prediction_length=12,
input_size=43,
trainer=Trainer(epochs=20, device=device))
# print('.....')
predictor = estimator.train(training_data=training_data)
test_data = ListDataset(
[{
"start": df.index[0],
"target": df.value[:"2015-04-15 00:00:00"]
}],
freq="5min",
)
for test_entry, forecast in zip(test_data, predictor.predict(test_data)):
to_pandas(test_entry)[-60:].plot(linewidth=2)
def __init__(
self,
input_size: int,
freq: str,
prediction_length: int,
target_dim: int,
trainer: Trainer = Trainer(),
context_length: Optional[int] = None,
num_layers: int = 2,
num_cells: int = 40,
cell_type: str = "LSTM",
num_parallel_samples: int = 100,
dropout_rate: float = 0.1,
cardinality: List[int] = [1],
embedding_dimension: int = 5,
flow_type="RealNVP",
n_blocks=3,
hidden_size=100,
n_hidden=2,
conditioning_length: int = 200,
dequantize: bool = False,
scaling: bool = True,
pick_incomplete: bool = False,
lags_seq: Optional[List[int]] = None,
time_features: Optional[List[TimeFeature]] = None,
**kwargs,
) -> None:
super().__init__(trainer=trainer, **kwargs)
self.freq = freq
self.context_length = (context_length if context_length is not None
else prediction_length)
self.input_size = input_size
self.prediction_length = prediction_length
self.target_dim = target_dim
self.num_layers = num_layers
self.num_cells = num_cells
self.cell_type = cell_type
self.num_parallel_samples = num_parallel_samples
self.dropout_rate = dropout_rate
self.cardinality = cardinality
self.embedding_dimension = embedding_dimension
self.flow_type = flow_type
self.n_blocks = n_blocks
self.hidden_size = hidden_size
self.n_hidden = n_hidden
self.conditioning_length = conditioning_length
self.dequantize = dequantize
self.lags_seq = (lags_seq if lags_seq is not None else
get_fourier_lags_for_frequency(freq_str=freq))
self.time_features = (time_features if time_features is not None else
fourier_time_features_from_frequency_str(
self.freq))
self.history_length = self.context_length + max(self.lags_seq)
self.pick_incomplete = pick_incomplete
self.scaling = scaling
def __init__(
self,
input_size: int,
freq: str,
prediction_length: int,
target_dim: int,
trainer: Trainer = Trainer(),
context_length: Optional[int] = None,
num_layers: int = 2,
num_cells: int = 40,
cell_type: str = "LSTM",
num_parallel_samples: int = 100,
dropout_rate: float = 0.1,
cardinality: List[int] = [1],
embedding_dimension: int = 5,
conditioning_length: int = 100,
diff_steps: int = 100,
loss_type: str = "l2",
beta_end=0.1,
beta_schedule="linear",
residual_layers=8,
residual_channels=8,
dilation_cycle_length=2,
scaling: bool = True,
pick_incomplete: bool = False,
lags_seq: Optional[List[int]] = None,
time_features: Optional[List[TimeFeature]] = None,
**kwargs,
) -> None:
super().__init__(trainer=trainer, **kwargs)
self.freq = freq
self.context_length = (context_length if context_length is not None
else prediction_length)
self.input_size = input_size
self.prediction_length = prediction_length
self.target_dim = target_dim
self.num_layers = num_layers
self.num_cells = num_cells
self.cell_type = cell_type
self.num_parallel_samples = num_parallel_samples
self.dropout_rate = dropout_rate
self.cardinality = cardinality
self.embedding_dimension = embedding_dimension
self.conditioning_length = conditioning_length
self.diff_steps = diff_steps
self.loss_type = loss_type
self.beta_end = beta_end
self.beta_schedule = beta_schedule
self.residual_layers = residual_layers
self.residual_channels = residual_channels
self.dilation_cycle_length = dilation_cycle_length
self.lags_seq = (lags_seq if lags_seq is not None else
lags_for_fourier_time_features_from_frequency(
freq_str=freq))
self.time_features = (time_features if time_features is not None else
fourier_time_features_from_frequency(self.freq))
self.history_length = self.context_length + max(self.lags_seq)
self.pick_incomplete = pick_incomplete
self.scaling = scaling
self.train_sampler = ExpectedNumInstanceSampler(
num_instances=1.0,
min_past=0 if pick_incomplete else self.history_length,
min_future=prediction_length,
)
self.validation_sampler = ValidationSplitSampler(
min_past=0 if pick_incomplete else self.history_length,
min_future=prediction_length,
)
def __init__(
self,
input_size: int,
freq: str,
prediction_length: int,
target_dim: int,
trainer: Trainer = Trainer(),
context_length: Optional[int] = None,
num_layers: int = 2,
num_cells: int = 40,
cell_type: str = "LSTM",
num_parallel_samples: int = 100,
dropout_rate: float = 0.1,
cardinality: List[int] = [1],
embedding_dimension: int = 5,
distr_output: Optional[DistributionOutput] = None,
rank: Optional[int] = 5,
scaling: bool = True,
pick_incomplete: bool = False,
lags_seq: Optional[List[int]] = None,
time_features: Optional[List[TimeFeature]] = None,
conditioning_length: int = 200,
use_marginal_transformation=False,
**kwargs,
) -> None:
super().__init__(trainer=trainer, **kwargs)
self.freq = freq
self.context_length = (context_length if context_length is not None
else prediction_length)
if distr_output is not None:
self.distr_output = distr_output
else:
self.distr_output = LowRankMultivariateNormalOutput(dim=target_dim,
rank=rank)
self.input_size = input_size
self.prediction_length = prediction_length
self.target_dim = target_dim
self.num_layers = num_layers
self.num_cells = num_cells
self.cell_type = cell_type
self.num_parallel_samples = num_parallel_samples
self.dropout_rate = dropout_rate
self.cardinality = cardinality
self.embedding_dimension = embedding_dimension
self.conditioning_length = conditioning_length
self.use_marginal_transformation = use_marginal_transformation
self.lags_seq = (lags_seq if lags_seq is not None else
get_fourier_lags_for_frequency(freq_str=freq))
self.time_features = (time_features if time_features is not None else
fourier_time_features_from_frequency_str(
self.freq))
self.history_length = self.context_length + max(self.lags_seq)
self.pick_incomplete = pick_incomplete
self.scaling = scaling
if self.use_marginal_transformation:
self.output_transform: Optional[
Callable] = cdf_to_gaussian_forward_transform
else:
self.output_transform = None
def __init__(
self,
freq: str,
prediction_length: int,
context_length: Optional[int] = None,
trainer: Trainer = Trainer(),
num_stacks: int = 30,
widths: Optional[List[int]] = None,
num_blocks: Optional[List[int]] = None,
num_block_layers: Optional[List[int]] = None,
expansion_coefficient_lengths: Optional[List[int]] = None,
sharing: Optional[List[bool]] = None,
stack_types: Optional[List[str]] = None,
loss_function: Optional[str] = "MAPE",
**kwargs,
) -> None:
super().__init__(trainer=trainer, **kwargs)
self.freq = freq
self.prediction_length = prediction_length
self.context_length = (context_length if context_length is not None
else 2 * prediction_length)
# num_stacks has to be handled separately because other arguments have to match its length
self.num_stacks = num_stacks
self.loss_function = loss_function
self.widths = self._validate_nbeats_argument(
argument_value=widths,
argument_name="widths",
default_value=[512],
validation_condition=lambda val: val > 0,
invalidation_message="Values of 'widths' should be > 0",
)
self.num_blocks = self._validate_nbeats_argument(
argument_value=num_blocks,
argument_name="num_blocks",
default_value=[1],
validation_condition=lambda val: val > 0,
invalidation_message="Values of 'num_blocks' should be > 0",
)
self.num_block_layers = self._validate_nbeats_argument(
argument_value=num_block_layers,
argument_name="num_block_layers",
default_value=[4],
validation_condition=lambda val: val > 0,
invalidation_message="Values of 'block_layers' should be > 0",
)
self.sharing = self._validate_nbeats_argument(
argument_value=sharing,
argument_name="sharing",
default_value=[False],
validation_condition=lambda val: True,
invalidation_message="",
)
self.expansion_coefficient_lengths = self._validate_nbeats_argument(
argument_value=expansion_coefficient_lengths,
argument_name="expansion_coefficient_lengths",
default_value=[32],
validation_condition=lambda val: val > 0,
invalidation_message=
"Values of 'expansion_coefficient_lengths' should be > 0",
)
self.stack_types = self._validate_nbeats_argument(
argument_value=stack_types,
argument_name="stack_types",
default_value=["G"],
validation_condition=lambda val: val in VALID_N_BEATS_STACK_TYPES,
invalidation_message=
f"Values of 'stack_types' should be one of {VALID_N_BEATS_STACK_TYPES}",
)