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}", )