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