def _encode(self, index: SupportedIndex, dtype: np.dtype) -> TimeSeries:
"""applies cyclic encoding from `datetime_attribute_timeseries()` to `self.attribute` of `index`."""
super()._encode(index, dtype)
return datetime_attribute_timeseries(index,
attribute=self.attribute,
cyclic=True,
dtype=dtype)
def helper_generate_multivariate_case_data(self, season_length,
n_repeat):
"""generates multivariate test case data. Target series is a sine wave stacked with a repeating
linear curve of equal seasonal length. Covariates are datetime attributes for 'hours'.
"""
# generate sine wave
ts_sine = tg.sine_timeseries(
value_frequency=1 / season_length,
length=n_repeat * season_length,
freq="h",
)
# generate repeating linear curve
ts_linear = tg.linear_timeseries(0,
1,
length=season_length,
start=ts_sine.end_time() +
ts_sine.freq)
for i in range(n_repeat - 1):
start = ts_linear.end_time() + ts_linear.freq
new_ts = tg.linear_timeseries(0,
1,
length=season_length,
start=start)
ts_linear = ts_linear.append(new_ts)
ts_linear = TimeSeries.from_times_and_values(
times=ts_sine.time_index, values=ts_linear.values())
# create multivariate TimeSeries by stacking sine and linear curves
ts = ts_sine.stack(ts_linear)
# create train/test sets
val_length = 10 * season_length
ts_train, ts_val = ts[:-val_length], ts[-val_length:]
# scale data
scaler_ts = Scaler()
ts_train_scaled = scaler_ts.fit_transform(ts_train)
ts_val_scaled = scaler_ts.transform(ts_val)
ts_scaled = scaler_ts.transform(ts)
# generate long enough covariates (past and future covariates will be the same for simplicity)
long_enough_ts = tg.sine_timeseries(value_frequency=1 /
season_length,
length=1000,
freq=ts.freq)
covariates = tg.datetime_attribute_timeseries(long_enough_ts,
attribute="hour")
scaler_covs = Scaler()
covariates_scaled = scaler_covs.fit_transform(covariates)
return ts_scaled, ts_train_scaled, ts_val_scaled, covariates_scaled
class GlobalForecastingModelsTestCase(DartsBaseTestClass):
# forecasting horizon used in runnability tests
forecasting_horizon = 12
np.random.seed(42)
torch.manual_seed(42)
# some arbitrary static covariates
static_covariates = pd.DataFrame([[0.0, 1.0]], columns=["st1", "st2"])
# real timeseries for functionality tests
ts_passengers = (AirPassengersDataset().load().with_static_covariates(
static_covariates))
scaler = Scaler()
ts_passengers = scaler.fit_transform(ts_passengers)
ts_pass_train, ts_pass_val = ts_passengers[:-36], ts_passengers[-36:]
# an additional noisy series
ts_pass_train_1 = ts_pass_train + 0.01 * tg.gaussian_timeseries(
length=len(ts_pass_train),
freq=ts_pass_train.freq_str,
start=ts_pass_train.start_time(),
)
# an additional time series serving as covariates
year_series = tg.datetime_attribute_timeseries(ts_passengers,
attribute="year")
month_series = tg.datetime_attribute_timeseries(ts_passengers,
attribute="month")
scaler_dt = Scaler()
time_covariates = scaler_dt.fit_transform(
year_series.stack(month_series))
time_covariates_train, time_covariates_val = (
time_covariates[:-36],
time_covariates[-36:],
)
# an artificial time series that is highly dependent on covariates
ts_length = 400
split_ratio = 0.6
sine_1_ts = tg.sine_timeseries(length=ts_length)
sine_2_ts = tg.sine_timeseries(length=ts_length, value_frequency=0.05)
sine_3_ts = tg.sine_timeseries(length=ts_length,
value_frequency=0.003,
value_amplitude=5)
linear_ts = tg.linear_timeseries(length=ts_length,
start_value=3,
end_value=8)
covariates = sine_3_ts.stack(sine_2_ts).stack(linear_ts)
covariates_past, _ = covariates.split_after(split_ratio)
target = sine_1_ts + sine_2_ts + linear_ts + sine_3_ts
target_past, target_future = target.split_after(split_ratio)
def test_save_model_parameters(self):
# model creation parameters were saved before. check if re-created model has same params as original
for model_cls, kwargs, err in models_cls_kwargs_errs:
model = model_cls(input_chunk_length=IN_LEN,
output_chunk_length=OUT_LEN,
**kwargs)
self.assertTrue(model._model_params,
model.untrained_model()._model_params)
def test_single_ts(self):
for model_cls, kwargs, err in models_cls_kwargs_errs:
model = model_cls(
input_chunk_length=IN_LEN,
output_chunk_length=OUT_LEN,
random_state=0,
**kwargs,
)
model.fit(self.ts_pass_train)
pred = model.predict(n=36)
mape_err = mape(self.ts_pass_val, pred)
self.assertTrue(
mape_err < err,
"Model {} produces errors too high (one time "
"series). Error = {}".format(model_cls, mape_err),
)
self.assertTrue(
pred.static_covariates.equals(
self.ts_passengers.static_covariates))
def test_multi_ts(self):
for model_cls, kwargs, err in models_cls_kwargs_errs:
model = model_cls(
input_chunk_length=IN_LEN,
output_chunk_length=OUT_LEN,
random_state=0,
**kwargs,
)
model.fit([self.ts_pass_train, self.ts_pass_train_1])
with self.assertRaises(ValueError):
# when model is fit from >1 series, one must provide a series in argument
model.predict(n=1)
pred = model.predict(n=36, series=self.ts_pass_train)
mape_err = mape(self.ts_pass_val, pred)
self.assertTrue(
mape_err < err,
"Model {} produces errors too high (several time "
"series). Error = {}".format(model_cls, mape_err),
)
# check prediction for several time series
pred_list = model.predict(
n=36, series=[self.ts_pass_train, self.ts_pass_train_1])
self.assertTrue(
len(pred_list) == 2,
f"Model {model_cls} did not return a list of prediction",
)
for pred in pred_list:
mape_err = mape(self.ts_pass_val, pred)
self.assertTrue(
mape_err < err,
"Model {} produces errors too high (several time series 2). "
"Error = {}".format(model_cls, mape_err),
)
def test_covariates(self):
for model_cls, kwargs, err in models_cls_kwargs_errs:
model = model_cls(
input_chunk_length=IN_LEN,
output_chunk_length=OUT_LEN,
random_state=0,
**kwargs,
)
# Here we rely on the fact that all non-Dual models currently are Past models
cov_name = ("future_covariates" if isinstance(
model, DualCovariatesTorchModel) else "past_covariates")
cov_kwargs = {
cov_name:
[self.time_covariates_train, self.time_covariates_train]
}
model.fit(series=[self.ts_pass_train, self.ts_pass_train_1],
**cov_kwargs)
with self.assertRaises(ValueError):
# when model is fit from >1 series, one must provide a series in argument
model.predict(n=1)
with self.assertRaises(ValueError):
# when model is fit using multiple covariates, covariates are required at prediction time
model.predict(n=1, series=self.ts_pass_train)
cov_kwargs_train = {cov_name: self.time_covariates_train}
cov_kwargs_notrain = {cov_name: self.time_covariates}
with self.assertRaises(ValueError):
# when model is fit using covariates, n cannot be greater than output_chunk_length...
model.predict(n=13,
series=self.ts_pass_train,
**cov_kwargs_train)
# ... unless future covariates are provided
pred = model.predict(n=13,
series=self.ts_pass_train,
**cov_kwargs_notrain)
pred = model.predict(n=12,
series=self.ts_pass_train,
**cov_kwargs_notrain)
mape_err = mape(self.ts_pass_val, pred)
self.assertTrue(
mape_err < err,
"Model {} produces errors too high (several time "
"series with covariates). Error = {}".format(
model_cls, mape_err),
)
# when model is fit using 1 training and 1 covariate series, time series args are optional
if model._is_probabilistic:
continue
model = model_cls(input_chunk_length=IN_LEN,
output_chunk_length=OUT_LEN,
**kwargs)
model.fit(series=self.ts_pass_train, **cov_kwargs_train)
pred1 = model.predict(1)
pred2 = model.predict(1, series=self.ts_pass_train)
pred3 = model.predict(1, **cov_kwargs_train)
pred4 = model.predict(1,
**cov_kwargs_train,
series=self.ts_pass_train)
self.assertEqual(pred1, pred2)
self.assertEqual(pred1, pred3)
self.assertEqual(pred1, pred4)
def test_future_covariates(self):
# models with future covariates should produce better predictions over a long forecasting horizon
# than a model trained with no covariates
model = TCNModel(
input_chunk_length=50,
output_chunk_length=5,
n_epochs=20,
random_state=0,
)
model.fit(series=self.target_past)
long_pred_no_cov = model.predict(n=160)
model = TCNModel(
input_chunk_length=50,
output_chunk_length=5,
n_epochs=20,
random_state=0,
)
model.fit(series=self.target_past,
past_covariates=self.covariates_past)
long_pred_with_cov = model.predict(n=160,
past_covariates=self.covariates)
self.assertTrue(
mape(self.target_future, long_pred_no_cov) > mape(
self.target_future, long_pred_with_cov),
"Models with future covariates should produce better predictions.",
)
# block models can predict up to self.output_chunk_length points beyond the last future covariate...
model.predict(n=165, past_covariates=self.covariates)
# ... not more
with self.assertRaises(ValueError):
model.predict(n=166, series=self.ts_pass_train)
# recurrent models can only predict data points for time steps where future covariates are available
model = RNNModel(12, n_epochs=1)
model.fit(series=self.target_past,
future_covariates=self.covariates_past)
model.predict(n=160, future_covariates=self.covariates)
with self.assertRaises(ValueError):
model.predict(n=161, future_covariates=self.covariates)
def test_batch_predictions(self):
# predicting multiple time series at once needs to work for arbitrary batch sizes
# univariate case
targets_univar = [
self.target_past,
self.target_past[:60],
self.target_past[:80],
]
self._batch_prediction_test_helper_function(targets_univar)
# multivariate case
targets_multivar = [tgt.stack(tgt) for tgt in targets_univar]
self._batch_prediction_test_helper_function(targets_multivar)
def _batch_prediction_test_helper_function(self, targets):
epsilon = 1e-4
model = TCNModel(
input_chunk_length=50,
output_chunk_length=10,
n_epochs=10,
random_state=0,
)
model.fit(series=targets[0], past_covariates=self.covariates_past)
preds_default = model.predict(
n=160,
series=targets,
past_covariates=[self.covariates] * len(targets),
batch_size=None,
)
# make batch size large enough to test stacking samples
for batch_size in range(1, 4 * len(targets)):
preds = model.predict(
n=160,
series=targets,
past_covariates=[self.covariates] * len(targets),
batch_size=batch_size,
)
for i in range(len(targets)):
self.assertLess(
sum(sum((preds[i] - preds_default[i]).values())),
epsilon)
def test_predict_from_dataset_unsupported_input(self):
# an exception should be thrown if an unsupported type is passed
unsupported_type = "unsupported_type"
# just need to test this with one model
model_cls, kwargs, err = models_cls_kwargs_errs[0]
model = model_cls(input_chunk_length=IN_LEN,
output_chunk_length=OUT_LEN,
**kwargs)
model.fit([self.ts_pass_train, self.ts_pass_train_1])
with self.assertRaises(ValueError):
model.predict_from_dataset(
n=1, input_series_dataset=unsupported_type)
def test_prediction_with_different_n(self):
# test model predictions for n < out_len, n == out_len and n > out_len
for model_cls, kwargs, err in models_cls_kwargs_errs:
model = model_cls(input_chunk_length=IN_LEN,
output_chunk_length=OUT_LEN,
**kwargs)
self.assertTrue(
isinstance(
model,
(
PastCovariatesTorchModel,
DualCovariatesTorchModel,
MixedCovariatesTorchModel,
),
),
"unit test not yet defined for the given {X}CovariatesTorchModel.",
)
if isinstance(model, PastCovariatesTorchModel):
past_covs, future_covs = self.covariates, None
elif isinstance(model, DualCovariatesTorchModel):
past_covs, future_covs = None, self.covariates
else:
past_covs, future_covs = self.covariates, self.covariates
model.fit(
self.target_past,
past_covariates=past_covs,
future_covariates=future_covs,
epochs=1,
)
# test prediction for n < out_len, n == out_len and n > out_len
for n in [OUT_LEN - 1, OUT_LEN, 2 * OUT_LEN - 1]:
pred = model.predict(n=n,
past_covariates=past_covs,
future_covariates=future_covs)
self.assertEqual(len(pred), n)
def test_same_result_with_different_n_jobs(self):
for model_cls, kwargs, err in models_cls_kwargs_errs:
model = model_cls(input_chunk_length=IN_LEN,
output_chunk_length=OUT_LEN,
**kwargs)
multiple_ts = [self.ts_pass_train] * 10
model.fit(multiple_ts)
# safe random state for two successive identical predictions
if model._is_probabilistic():
random_state = deepcopy(model._random_instance)
else:
random_state = None
pred1 = model.predict(n=36, series=multiple_ts, n_jobs=1)
if random_state is not None:
model._random_instance = random_state
pred2 = model.predict(
n=36, series=multiple_ts,
n_jobs=-1) # assuming > 1 core available in the machine
self.assertEqual(
pred1,
pred2,
"Model {} produces different predictions with different number of jobs",
)
@patch(
"darts.models.forecasting.torch_forecasting_model.TorchForecastingModel._init_trainer"
)
def test_fit_with_constr_epochs(self, init_trainer):
for model_cls, kwargs, err in models_cls_kwargs_errs:
model = model_cls(input_chunk_length=IN_LEN,
output_chunk_length=OUT_LEN,
**kwargs)
multiple_ts = [self.ts_pass_train] * 10
model.fit(multiple_ts)
init_trainer.assert_called_with(max_epochs=kwargs["n_epochs"],
trainer_params=ANY)
@patch(
"darts.models.forecasting.torch_forecasting_model.TorchForecastingModel._init_trainer"
)
def test_fit_with_fit_epochs(self, init_trainer):
for model_cls, kwargs, err in models_cls_kwargs_errs:
model = model_cls(input_chunk_length=IN_LEN,
output_chunk_length=OUT_LEN,
**kwargs)
multiple_ts = [self.ts_pass_train] * 10
epochs = 3
model.fit(multiple_ts, epochs=epochs)
init_trainer.assert_called_with(max_epochs=epochs,
trainer_params=ANY)
model.total_epochs = epochs
# continue training
model.fit(multiple_ts, epochs=epochs)
init_trainer.assert_called_with(max_epochs=epochs,
trainer_params=ANY)
@patch(
"darts.models.forecasting.torch_forecasting_model.TorchForecastingModel._init_trainer"
)
def test_fit_from_dataset_with_epochs(self, init_trainer):
for model_cls, kwargs, err in models_cls_kwargs_errs:
model = model_cls(input_chunk_length=IN_LEN,
output_chunk_length=OUT_LEN,
**kwargs)
multiple_ts = [self.ts_pass_train] * 10
train_dataset = model._build_train_dataset(
multiple_ts,
past_covariates=None,
future_covariates=None,
max_samples_per_ts=None,
)
epochs = 3
model.fit_from_dataset(train_dataset, epochs=epochs)
init_trainer.assert_called_with(max_epochs=epochs,
trainer_params=ANY)
# continue training
model.fit_from_dataset(train_dataset, epochs=epochs)
init_trainer.assert_called_with(max_epochs=epochs,
trainer_params=ANY)
def test_predit_after_fit_from_dataset(self):
model_cls, kwargs, _ = models_cls_kwargs_errs[0]
model = model_cls(input_chunk_length=IN_LEN,
output_chunk_length=OUT_LEN,
**kwargs)
multiple_ts = [self.ts_pass_train] * 10
train_dataset = model._build_train_dataset(
multiple_ts,
past_covariates=None,
future_covariates=None,
max_samples_per_ts=None,
)
model.fit_from_dataset(train_dataset, epochs=3)
# test predict() works after fit_from_dataset()
model.predict(n=1, series=multiple_ts[0])
def test_sample_smaller_than_batch_size(self):
"""
Checking that the TorchForecastingModels do not crash even if the number of available samples for training
is strictly lower than the selected batch_size
"""
# TS with 50 timestamps. TorchForecastingModels will use the SequentialDataset for producing training
# samples, which means we will have 50 - 22 - 2 + 1 = 27 samples, which is < 32 (batch_size). The model
# should still train on those samples and not crash in any way
ts = linear_timeseries(start_value=0, end_value=1, length=50)
model = RNNModel(input_chunk_length=20,
output_chunk_length=2,
n_epochs=2,
batch_size=32)
model.fit(ts)
def test_max_samples_per_ts(self):
"""
Checking that we can fit TorchForecastingModels with max_samples_per_ts, without crash
"""
ts = linear_timeseries(start_value=0, end_value=1, length=50)
model = RNNModel(input_chunk_length=20,
output_chunk_length=2,
n_epochs=2,
batch_size=32)
model.fit(ts, max_samples_per_ts=5)
def test_residuals(self):
"""
Torch models should not fail when computing residuals on a series
long enough to accomodate at least one training sample.
"""
ts = linear_timeseries(start_value=0, end_value=1, length=38)
model = NBEATSModel(
input_chunk_length=24,
output_chunk_length=12,
num_stacks=2,
num_blocks=1,
num_layers=1,
layer_widths=2,
n_epochs=2,
)
model.residuals(ts)
class CovariateIndexGeneratorTestCase(DartsBaseTestClass):
n_target = 24
target_time = tg.linear_timeseries(length=n_target, freq="MS")
cov_time_train = tg.datetime_attribute_timeseries(target_time,
attribute="month",
cyclic=True)
cov_time_train_short = cov_time_train[1:]
target_int = tg.linear_timeseries(length=n_target, start=2)
cov_int_train = target_int
cov_int_train_short = cov_int_train[1:]
input_chunk_length = 12
output_chunk_length = 6
n_short = 6
n_long = 8
# pd.DatetimeIndex
# target covariate for inference dataset for n <= output_chunk_length
cov_time_inf_short = TimeSeries.from_times_and_values(
tg._generate_index(
start=target_time.start_time(),
length=n_target + n_short,
freq=target_time.freq,
),
np.arange(n_target + n_short),
)
# target covariate for inference dataset for n > output_chunk_length
cov_time_inf_long = TimeSeries.from_times_and_values(
tg._generate_index(
start=target_time.start_time(),
length=n_target + n_long,
freq=target_time.freq,
),
np.arange(n_target + n_long),
)
# integer index
# target covariate for inference dataset for n <= output_chunk_length
cov_int_inf_short = TimeSeries.from_times_and_values(
tg._generate_index(
start=target_int.start_time(),
length=n_target + n_short,
freq=target_int.freq,
),
np.arange(n_target + n_short),
)
# target covariate for inference dataset for n > output_chunk_length
cov_int_inf_long = TimeSeries.from_times_and_values(
tg._generate_index(
start=target_int.start_time(),
length=n_target + n_long,
freq=target_int.freq,
),
np.arange(n_target + n_long),
)
def helper_test_index_types(self, ig: CovariateIndexGenerator):
"""test the index type of generated index"""
# pd.DatetimeIndex
idx = ig.generate_train_series(self.target_time, self.cov_time_train)
self.assertTrue(isinstance(idx, pd.DatetimeIndex))
idx = ig.generate_inference_series(self.n_short, self.target_time,
self.cov_time_inf_short)
self.assertTrue(isinstance(idx, pd.DatetimeIndex))
idx = ig.generate_train_series(self.target_time, None)
self.assertTrue(isinstance(idx, pd.DatetimeIndex))
# pd.RangeIndex
idx = ig.generate_train_series(self.target_int, self.cov_int_train)
self.assertTrue(isinstance(idx, pd.RangeIndex))
idx = ig.generate_inference_series(self.n_short, self.target_int,
self.cov_int_inf_short)
self.assertTrue(isinstance(idx, pd.RangeIndex))
idx = ig.generate_train_series(self.target_int, None)
self.assertTrue(isinstance(idx, pd.RangeIndex))
def helper_test_index_generator_train(self, ig: CovariateIndexGenerator):
"""
If covariates are given, the index generators should return the covariate series' index.
If covariates are not given, the index generators should return the target series' index.
"""
# pd.DatetimeIndex
# generated index must be equal to input covariate index
idx = ig.generate_train_series(self.target_time, self.cov_time_train)
self.assertTrue(idx.equals(self.cov_time_train.time_index))
# generated index must be equal to input covariate index
idx = ig.generate_train_series(self.target_time,
self.cov_time_train_short)
self.assertTrue(idx.equals(self.cov_time_train_short.time_index))
# generated index must be equal to input target index when no covariates are defined
idx = ig.generate_train_series(self.target_time, None)
self.assertTrue(idx.equals(self.cov_time_train.time_index))
# integer index
# generated index must be equal to input covariate index
idx = ig.generate_train_series(self.target_int, self.cov_int_train)
self.assertTrue(idx.equals(self.cov_int_train.time_index))
# generated index must be equal to input covariate index
idx = ig.generate_train_series(self.target_time,
self.cov_int_train_short)
self.assertTrue(idx.equals(self.cov_int_train_short.time_index))
# generated index must be equal to input target index when no covariates are defined
idx = ig.generate_train_series(self.target_int, None)
self.assertTrue(idx.equals(self.cov_int_train.time_index))
def helper_test_index_generator_inference(self, ig, is_past=False):
"""
For prediction (`n` is given) with past covariates we have to distinguish between two cases:
1) if past covariates are given, we can use them as reference
2) if past covariates are missing, we need to generate a time index that starts `input_chunk_length`
before the end of `target` and ends `max(0, n - output_chunk_length)` after the end of `target`
For prediction (`n` is given) with future covariates we have to distinguish between two cases:
1) if future covariates are given, we can use them as reference
2) if future covariates are missing, we need to generate a time index that starts `input_chunk_length`
before the end of `target` and ends `max(n, output_chunk_length)` after the end of `target`
"""
# check generated inference index without passing covariates when n <= output_chunk_length
idx = ig.generate_inference_series(self.n_short, self.target_time,
None)
if is_past:
n_out = self.input_chunk_length
last_idx = self.target_time.end_time()
else:
n_out = self.input_chunk_length + self.output_chunk_length
last_idx = self.cov_time_inf_short.end_time()
self.assertTrue(len(idx) == n_out)
self.assertTrue(idx[-1] == last_idx)
# check generated inference index without passing covariates when n > output_chunk_length
idx = ig.generate_inference_series(self.n_long, self.target_time, None)
if is_past:
n_out = self.input_chunk_length + self.n_long - self.output_chunk_length
last_idx = (self.target_time.end_time() +
(self.n_long - self.output_chunk_length) *
self.target_time.freq)
else:
n_out = self.input_chunk_length + self.n_long
last_idx = self.cov_time_inf_long.end_time()
self.assertTrue(len(idx) == n_out)
self.assertTrue(idx[-1] == last_idx)
idx = ig.generate_inference_series(self.n_short, self.target_time,
self.cov_time_inf_short)
self.assertTrue(idx.equals(self.cov_time_inf_short.time_index))
idx = ig.generate_inference_series(self.n_long, self.target_time,
self.cov_time_inf_long)
self.assertTrue(idx.equals(self.cov_time_inf_long.time_index))
idx = ig.generate_inference_series(self.n_short, self.target_int,
self.cov_int_inf_short)
self.assertTrue(idx.equals(self.cov_int_inf_short.time_index))
idx = ig.generate_inference_series(self.n_long, self.target_int,
self.cov_int_inf_long)
self.assertTrue(idx.equals(self.cov_int_inf_long.time_index))
def test_past_index_generator(self):
ig = PastCovariateIndexGenerator(self.input_chunk_length,
self.output_chunk_length)
self.helper_test_index_types(ig)
self.helper_test_index_generator_train(ig)
self.helper_test_index_generator_inference(ig, is_past=True)
def test_future_index_generator(self):
ig = FutureCovariateIndexGenerator(self.input_chunk_length,
self.output_chunk_length)
self.helper_test_index_types(ig)
self.helper_test_index_generator_train(ig)
self.helper_test_index_generator_inference(ig, is_past=False)
def helper_test_cyclic_encoder(self, encoder_class, attribute,
inf_ts_short, inf_ts_long, cyclic):
"""Test cases for both `PastCyclicEncoder` and `FutureCyclicEncoder`"""
encoder = encoder_class(
input_chunk_length=self.input_chunk_length,
output_chunk_length=self.output_chunk_length,
attribute=attribute,
)
# covs: covariates; ds: dataset
# expected generated covs when covs are supplied as input for train and inference ds
result_with_cov = [
tg.datetime_attribute_timeseries(ts,
attribute=attribute,
cyclic=cyclic)
for ts in self.covariate_multi
]
# expected generated covs when covs are not supplied as input for train ds
result_no_cov = [
tg.datetime_attribute_timeseries(ts,
attribute=attribute,
cyclic=cyclic)
for ts in self.target_multi
]
# expected generated covs when covs are not supplied as input for inference ds and n <= output_chunk_length
result_no_cov_inf_short = [
tg.datetime_attribute_timeseries(ts,
attribute=attribute,
cyclic=cyclic)
for ts in inf_ts_short
]
# expected generated covs when covs are not supplied as input for inference ds and n > output_chunk_length
result_no_cov_inf_long = [
tg.datetime_attribute_timeseries(ts,
attribute=attribute,
cyclic=cyclic)
for ts in inf_ts_long
]
# test train encoding with covariates
self.helper_test_encoder_single_train(
encoder=encoder,
target=self.target_multi,
covariate=self.covariate_multi,
result=result_with_cov,
merge_covariates=False,
)
# test train encoding without covariates
self.helper_test_encoder_single_train(
encoder=encoder,
target=self.target_multi,
covariate=[None] * len(self.target_multi),
result=result_no_cov,
merge_covariates=False,
)
# test inference encoding with covariates and n <= output_chunk_length
self.helper_test_encoder_single_inference(
encoder=encoder,
n=self.n_short,
target=self.target_multi,
covariate=self.covariate_multi,
result=result_with_cov,
merge_covariates=False,
)
# test inference encoding with covariates and n > output_chunk_length
self.helper_test_encoder_single_inference(
encoder=encoder,
n=self.n_long,
target=self.target_multi,
covariate=self.covariate_multi,
result=result_with_cov,
merge_covariates=False,
)
# test inference encoding without covariates and n <= output_chunk_length
self.helper_test_encoder_single_inference(
encoder=encoder,
n=self.n_short,
target=self.target_multi,
covariate=[None] * len(self.target_multi),
result=result_no_cov_inf_short,
merge_covariates=False,
)
# test inference encoding without covariates and n > output_chunk_length
self.helper_test_encoder_single_inference(
encoder=encoder,
n=self.n_long,
target=self.target_multi,
covariate=[None] * len(self.target_multi),
result=result_no_cov_inf_long,
merge_covariates=False,
)