def from_data_entry(cls,
item: DataEntry,
freq: Optional[str] = None) -> "TimeSeriesSlice":
if freq is None:
freq = item["start"].freq
index = pd.period_range(start=item["start"],
freq=freq,
periods=len(item["target"]))
feat_dynamic_cat = [
pd.Series(cat, index=index)
for cat in list(item.get("feat_dynamic_cat", []))
]
feat_dynamic_real = [
pd.Series(real, index=index)
for real in list(item.get("feat_dynamic_real", []))
]
feat_static_cat = list(item.get("feat_static_cat", []))
feat_static_real = list(item.get("feat_static_real", []))
return TimeSeriesSlice(
target=pd.Series(item["target"], index=index),
item=item[FieldName.ITEM_ID],
feat_static_cat=feat_static_cat,
feat_static_real=feat_static_real,
feat_dynamic_cat=feat_dynamic_cat,
feat_dynamic_real=feat_dynamic_real,
)
def predict_item(self, item: DataEntry) -> SampleForecast:
return SampleForecast(
samples=self.samples,
start_date=item["start"],
freq=self.freq,
item_id=item.get(FieldName.ITEM_ID),
)
def _make_prophet_data_entry(self, entry: DataEntry) -> ProphetDataEntry:
"""
Construct a :class:`ProphetDataEntry` from a regular
:class:`DataEntry`.
"""
train_length = len(entry["target"])
prediction_length = self.prediction_length
start = entry["start"]
target = entry["target"]
feat_dynamic_real = entry.get("feat_dynamic_real", [])
# make sure each dynamic feature has the desired length
for i, feature in enumerate(feat_dynamic_real):
assert len(feature) == train_length + prediction_length, (
f"Length mismatch for dynamic real-valued feature #{i}: "
f"expected {train_length + prediction_length}, "
f"got {len(feature)}")
return ProphetDataEntry(
train_length=train_length,
prediction_length=prediction_length,
start=start,
target=target,
feat_dynamic_real=feat_dynamic_real,
)
def predict_item(self, item: DataEntry) -> SampleForecast:
samples_shape = self.num_samples, self.prediction_length
samples = np.full(samples_shape, self.value)
return SampleForecast(
samples=samples,
start_date=forecast_start(item),
item_id=item.get("id"),
)
def predict_item(self, item: DataEntry) -> Forecast:
prediction = item["target"][-self.prediction_length:]
samples = np.broadcast_to(
array=np.expand_dims(prediction, 0),
shape=(self.num_samples, self.prediction_length),
)
return SampleForecast(
samples=samples,
start_date=forecast_start(item),
item_id=item.get(FieldName.ITEM_ID),
)
def predict_item(self, item: DataEntry) -> SampleForecast:
if self.context_length is not None:
target = item["target"][-self.context_length:]
else:
target = item["target"]
mean = np.nanmean(target)
std = np.nanstd(target)
normal = np.random.standard_normal(self.shape)
return SampleForecast(
samples=std * normal + mean,
start_date=forecast_start(item),
item_id=item.get(FieldName.ITEM_ID),
)
def predict_item(self, item: DataEntry) -> SampleForecast:
target = item["target"].tolist()
for _ in range(self.prediction_length):
if self.context_length is not None:
window = target[-self.context_length:]
else:
window = target
target.append(np.nanmean(window))
return SampleForecast(
samples=np.array([target[-self.prediction_length:]]),
start_date=forecast_start(item),
item_id=item.get(FieldName.ITEM_ID),
)
def predict_item(self, item: DataEntry) -> Forecast:
past_ts_data = item["target"]
item_id = item.get("item_id", None)
forecast_start_time = forecast_start(item)
assert (
len(past_ts_data) >= 1
), "all time series should have at least one data point"
prediction = naive_2(past_ts_data, self.prediction_length, self.freq)
samples = np.array([prediction])
return SampleForecast(
samples=samples,
start_date=forecast_start_time,
item_id=item_id,
)
def predict_item(self, item: DataEntry) -> Forecast:
target = np.asarray(item["target"], np.float32)
len_ts = len(target)
forecast_start_time = forecast_start(item)
assert (len_ts >=
1), "all time series should have at least one data point"
if len_ts >= self.season_length:
indices = [
len_ts - self.season_length + k % self.season_length
for k in range(self.prediction_length)
]
samples = target[indices].reshape((1, self.prediction_length))
else:
samples = np.full(shape=(1, self.prediction_length),
fill_value=target.mean())
return SampleForecast(
samples=samples,
start_date=forecast_start_time,
item_id=item.get("item_id", None),
)