def normalize(self):
"""
Normalizes a series using point-relative normalization.
Parameters
----------
Returns
-------
"""
normalizations.point_relative_normalization()
def predict(self, output=None, denormalized=False, return_dict=False):
"""
Makes a prediction based on input data.
Parameters
----------
output: int, default None
Output index in a multi-output model.
It is unused in a single-output model
denormalized: bool, default True
If method should denormalize data. Method
will use the normalizations.point_relative_normalization()
return_dict: bool, default False
If should return dict that can be serializable
as JSON. Useful for returning prediction
results with dates as keys.
"""
if self.model_type == 'sequential':
predictions = self.model.predict(x=self.X)
else:
predictions = self.model.predict(x=self.X)[output]
if denormalized:
predictions = point_relative_normalization(
series=predictions, reverse=True, last_value=self.last_value)
dates = []
base_date = datetime.strptime(self.last_date, '%Y-%m-%d')
for i in range(1, len(predictions[0]) + 1):
d = (base_date + timedelta(days=i)).strftime('%Y-%m-%d')
dates.append(d)
results = []
for d, p in zip(dates, predictions[0].tolist()):
results.append({'date': d, 'prediction': round(p, 2)})
if return_dict:
return results
else:
return predictions[0]
def predict(self, denormalized=False, return_dict=False):
"""
Makes a prediction based on input data.
Parameters
----------
denormalized: bool, default True
If method should denormalize data. Method
will use the normalizations.point_relative_normalization()
return_dict: bool, default False
If should return dict that can be serializable
as JSON. Useful for returning prediction
results with dates as keys.
"""
predictions = self.model.predict(x=self.X)
if denormalized:
predictions = point_relative_normalization(series=predictions,
reverse=True,
last_value=self.last_value)
dates = []
#print(self.last_date)
x = pd.to_datetime(self.last_date)
date = str(x.date())
base_date = datetime.strptime(date, '%Y-%m-%d')
for i in range(1, len(predictions[0] + 1)):
d = (base_date + timedelta(days=i)).strftime('%Y-%m-%d')
dates.append(d)
results = []
for d,p in zip(dates, predictions[0].tolist()):
results.append({
'date': d,
'prediction': round(p, 2)
})
if return_dict:
return results
else:
return predictions[0]
def create_groups(self, data, start=0, group_size=7, normalize=True):
"""
Creates distinct groups from a given continuous series.
Parameters
----------
data: np.array
Series of continious observations.
start: int
Starting point for the series. This
is used to prune earlier observations
from the series in case the series is
too long or too short.
group_size: int, default 7
Determines how large the groups are. That is,
how many observations each group contains.
normalize: bool
If the method should normalize data or not.
Normalization is done using
normalizations.point_relative_normalization()
Returns
-------
A Numpy array object.
"""
samples = list()
for i in range(0, len(data), group_size):
sample = list(data[start + i:i + group_size])
if len(sample) == group_size:
if normalize:
sample = normalizations.point_relative_normalization(
sample)
samples.append(
np.array(sample).reshape(1, group_size).tolist())
A = np.array(samples)
return A.reshape(1, A.shape[0], group_size)
def evaluate(self, metrics=['mse', 'rmse', 'mape']):
"""
Evaluates model using provided metrics. The evaluation
"""
y = point_relative_normalization(series=self.Y[0],
reverse=True,
last_value=self.last_value)
results = {}
for metric in metrics:
if metric == 'mse':
r = round(self.mse(A=self.Y[0], B=self.predict()), 2)
else:
r = round(
getattr(self, metric)(A=self.predict(denormalized=True)[0],
B=y), 2)
results[metric] = r
return results