From 4ab900ee4825e855ca57423ebd9004e667b7c406 Mon Sep 17 00:00:00 2001 From: koren Date: Wed, 21 Sep 2022 17:29:21 +0300 Subject: [PATCH 01/12] nothing much --- data/Data_files_here.txt | 2 - src/framework__data_set.py | 53 +++++++++++++++++++++++---- src/framework__test_bench.py | 12 +++++- src/framework_pytorch_lstm.py | 18 ++++----- src/pytorch__driver_for_test_bench.py | 2 +- 5 files changed, 66 insertions(+), 21 deletions(-) delete mode 100644 data/Data_files_here.txt diff --git a/data/Data_files_here.txt b/data/Data_files_here.txt deleted file mode 100644 index 7fcb6fe..0000000 --- a/data/Data_files_here.txt +++ /dev/null @@ -1,2 +0,0 @@ -Instead of this txt file, put here JSON files with the relevant data. - diff --git a/src/framework__data_set.py b/src/framework__data_set.py index 96570f2..aeff396 100644 --- a/src/framework__data_set.py +++ b/src/framework__data_set.py @@ -68,7 +68,27 @@ def sub_sample_data(self, sub_sample_rate): new_list_of_df = [] for df in self: + # for i in range(10): + # print(df.loc[[i]]) sub_sampled_data = df.groupby(df.index // sub_sample_rate).max() + # print(sub_sampled_data.loc[[0]]) + # exit() + assert len(sub_sampled_data) == ((len(df) + sub_sample_rate - 1) // sub_sample_rate) + new_list_of_df.append(sub_sampled_data) + + self.__list_of_df = new_list_of_df + + # todo: fix the bug where the "time" column is disappear + def mean_sub_sample_data(self, sub_sample_rate): + """ + creates sub sampling according to the rate (if for example rate = 5, then every 5 samples, the one with the + mean value is chosen to be in the data set). + @param sub_sample_rate: + """ + new_list_of_df = [] + + for df in self: + sub_sampled_data = df.groupby(df.index // sub_sample_rate).mean() assert len(sub_sampled_data) == ((len(df) + sub_sample_rate - 1) // sub_sample_rate) new_list_of_df.append(sub_sampled_data) @@ -101,6 +121,24 @@ def plot_dataset(self, number_of_samples): ts.plot() plt.show() + + def plot_not_random_dataset(self, number_of_samples): + """ + not randomly selects samples from the data sets and plots . x-axis is time and y-axis is the value + @param number_of_samples: number of selected samples + """ + print("Totam number of TS are: ", len(self.__list_of_df)) + counter = 0 + for df in self.__list_of_df: + if counter == number_of_samples: + break + ts = df["sample"].copy() + ts.index = [time for time in df["time"]] + ts.plot() + plt.show() + counter += 1 + + def scale_data(self): """ rescaling the distribution of values so that the mean of observed values is 0, and the std is 1. @@ -109,7 +147,7 @@ def scale_data(self): assert not self.__is_data_scaled self.__is_data_scaled = True self.__mean, self.__std = self.__get_mean_and_std() - # print(f"self.__mean = {self.__mean}, self.__std = {self.__std}", ) + # print(f"self.__mean = {self.__mean}, self.__std = {self.__std}" , ) # print("max_sample = ", max_sample, " min_sample = ", min_sample) for df in self: standardized_sample_column = (df["sample"] - self.__mean) / self.__std @@ -295,14 +333,15 @@ def main(): if test == 0: print("Getting DataSet.") dataset = get_data_set( - metric="container_mem", - application_name="bridge-marker", + metric="container_cpu", + application_name="collector", path_to_data="../data/" ) print("Plotting.") - dataset.plot_dataset(number_of_samples=3) + dataset.plot_not_random_dataset(number_of_samples=25) print("Subsampling.") - dataset.sub_sample_data(sub_sample_rate=60) + exit() + dataset.sub_sample_data(sub_sample_rate=10) print("Plotting.") dataset.plot_dataset(number_of_samples=3) print("Normalizing.") @@ -314,8 +353,8 @@ def main(): print("Splitting.") train, test = dataset.split_to_train_and_test(length_to_predict=length_to_predict) print("Plotting.") - train.plot_dataset(number_of_samples=10) - test.plot_dataset(number_of_samples=10) + train.plot_dataset(number_of_samples=3) + test.plot_dataset(number_of_samples=3) else: hist = get_amount_of_data_per_application( metric="container_mem", diff --git a/src/framework__test_bench.py b/src/framework__test_bench.py index a16aa8b..7623388 100644 --- a/src/framework__test_bench.py +++ b/src/framework__test_bench.py @@ -12,7 +12,7 @@ from sktime.performance_metrics.forecasting import MeanAbsoluteScaledError from sktime.performance_metrics.forecasting import MeanAbsolutePercentageError from sktime.performance_metrics.forecasting import MeanSquaredError -from src.framework__data_set import get_data_set +from framework__data_set import get_data_set """ *********************************************************************************************************************** @@ -404,4 +404,12 @@ def main(test_to_perform): {"metric": "node_mem", "app": "emea/balrog", "prediction length": 16, "sub sample rate": 30, "data length limit": 30} ) - main(test_to_perform) + + real_test_to_perform = ( + # Container CPU + {"metric": "container_cpu", "app": "kube-rbac-proxy", "prediction length": 16, "sub sample rate": 10, + "data length limit": 80}, + {"metric": "container_cpu", "app": "dns", "prediction length": 16, "sub sample rate": 30, + "data length limit": 30}, + ) + main(real_test_to_perform) diff --git a/src/framework_pytorch_lstm.py b/src/framework_pytorch_lstm.py index d522e19..ad7287f 100644 --- a/src/framework_pytorch_lstm.py +++ b/src/framework_pytorch_lstm.py @@ -4,7 +4,7 @@ *********************************************************************************************************************** """ -import src.pytorch__driver_for_test_bench as pytorch__driver_for_test_bench +import pytorch__driver_for_test_bench as pytorch__driver_for_test_bench import torch.nn as nn import torch.optim as optim @@ -42,17 +42,17 @@ def forward(x): class LSTMPredictor(nn.Module): def __init__(self, input_size, output_size): super(LSTMPredictor, self).__init__() - hidden_size_for_lstm = 200 - internal_hidden_dimension = 32 - num_layers = 2 - dropout = 0.03 + hidden_size_for_lstm = 20 + internal_hidden_dimension = 5 + num_layers = 1 + # dropout = 0.03 self.__seq_model = nn.Sequential( nn.LSTM( input_size=input_size, hidden_size=hidden_size_for_lstm, num_layers=num_layers, batch_first=True, - dropout=dropout, + # dropout=dropout, ), ExtractTensorAfterLSTM(), nn.Linear( @@ -129,7 +129,7 @@ def predict(self, ts_as_df_start, how_much_to_predict): def main(test_to_perform): - import src.framework__test_bench as framework__test_bench + import framework__test_bench as framework__test_bench tb = framework__test_bench.TestBench( class_to_test=PytorchLSTMTester, path_to_data="../data/", @@ -147,8 +147,8 @@ def main(test_to_perform): if __name__ == "__main__": test_to_perform = ( # Container CPU - {"metric": "container_cpu", "app": "kube-rbac-proxy", "prediction length": 16, "sub sample rate": 30, - "data length limit": 30}, + {"metric": "container_cpu", "app": "collector", "prediction length": 5, "sub sample rate": 5, + "data length limit": 50}, {"metric": "container_cpu", "app": "dns", "prediction length": 16, "sub sample rate": 30, "data length limit": 30} # {"metric": "container_cpu", "app": "collector", "prediction length": 16, "sub sample rate": 30, diff --git a/src/pytorch__driver_for_test_bench.py b/src/pytorch__driver_for_test_bench.py index 5b0a837..e8218d6 100644 --- a/src/pytorch__driver_for_test_bench.py +++ b/src/pytorch__driver_for_test_bench.py @@ -10,7 +10,7 @@ from torch.autograd import Variable import random import math -import src.framework__test_bench as framework__test_bench +import framework__test_bench as framework__test_bench import time """ From b0e2797f36986e9854e3ff613c26027bf0bd977f Mon Sep 17 00:00:00 2001 From: koren Date: Sun, 25 Sep 2022 12:03:41 +0300 Subject: [PATCH 02/12] add option to concat dataframes of the same app --- src/framework__data_set.py | 45 ++++++++++++++++++++++++++++++++++---- 1 file changed, 41 insertions(+), 4 deletions(-) diff --git a/src/framework__data_set.py b/src/framework__data_set.py index aeff396..4cdcb02 100644 --- a/src/framework__data_set.py +++ b/src/framework__data_set.py @@ -12,6 +12,9 @@ from os import listdir from os.path import isfile, join import numpy as np +from darts.datasets import (AirPassengersDataset, MonthlyMilkDataset, + AusBeerDataset, GasRateCO2Dataset, WoolyDataset, ElectricityDataset) +# from darts.models.filtering.kalman_filter import KalmanFilter """ *********************************************************************************************************************** @@ -29,6 +32,7 @@ def __init__(self, list_of_df): self.__is_data_scaled = False self.__mean = None self.__std = None + self.merged_df = None """ ******************************************************************************************************************* @@ -59,6 +63,22 @@ def __getitem__(self, key): def __len__(self): return len(self.__list_of_df) + def merge_df(self): + """ + concat all the dataframes of the same application + """ + self.merged_df = pd.concat(self.__list_of_df) + + def sort_by_time(self): + """ + concat all the dataframes of the same application + and sort them by time + """ + self.merge_df() + self.merged_df = self.merged_df.sort_values(by="time") + # todo: figure out why there is too much samples + + def sub_sample_data(self, sub_sample_rate): """ creates sub sampling according to the rate (if for example rate = 5, then every 5 samples, the one with the @@ -68,11 +88,7 @@ def sub_sample_data(self, sub_sample_rate): new_list_of_df = [] for df in self: - # for i in range(10): - # print(df.loc[[i]]) sub_sampled_data = df.groupby(df.index // sub_sample_rate).max() - # print(sub_sampled_data.loc[[0]]) - # exit() assert len(sub_sampled_data) == ((len(df) + sub_sample_rate - 1) // sub_sample_rate) new_list_of_df.append(sub_sampled_data) @@ -327,6 +343,25 @@ def get_amount_of_data_per_application(metric, path_to_data): def main(): + # ts1 = AirPassengersDataset().load() + # ts2 = WoolyDataset().load() + # ts3 = AusBeerDataset().load() + # ts4 = GasRateCO2Dataset().load() + # ts5 = ElectricityDataset().load() + # ts6 = MonthlyMilkDataset().load() + # ts1.plot() + # plt.show() + # ts2.plot() + # plt.show() + # ts3.plot() + # plt.show() + # ts4.plot() + # plt.show() + # ts5.plot() + # plt.show() + # ts6.plot() + # plt.show() + # exit() print("Start.") length_to_predict = 4 test = 0 @@ -338,6 +373,8 @@ def main(): path_to_data="../data/" ) print("Plotting.") + print(dataset.sort_by_time()) + exit() dataset.plot_not_random_dataset(number_of_samples=25) print("Subsampling.") exit() From 725d344f89a673f663dfa5e7b19d1a1ad690e5fd Mon Sep 17 00:00:00 2001 From: koren Date: Tue, 25 Oct 2022 16:23:26 +0300 Subject: [PATCH 03/12] add features extraction --- src/framework__data_set.py | 24 +++++++++++++++--------- 1 file changed, 15 insertions(+), 9 deletions(-) diff --git a/src/framework__data_set.py b/src/framework__data_set.py index 4cdcb02..04b9734 100644 --- a/src/framework__data_set.py +++ b/src/framework__data_set.py @@ -67,6 +67,7 @@ def merge_df(self): """ concat all the dataframes of the same application """ + # todo: fix the merging of same apps on different pods and namespaces self.merged_df = pd.concat(self.__list_of_df) def sort_by_time(self): @@ -76,8 +77,6 @@ def sort_by_time(self): """ self.merge_df() self.merged_df = self.merged_df.sort_values(by="time") - # todo: figure out why there is too much samples - def sub_sample_data(self, sub_sample_rate): """ @@ -94,13 +93,24 @@ def sub_sample_data(self, sub_sample_rate): self.__list_of_df = new_list_of_df - # todo: fix the bug where the "time" column is disappear + def add_features(self): # 2022-04-21 02:50:00 - example + """ + Adding to the DataFrame "hour" and "day of week" columns for using those columns as features later + """ + # todo: figure out if one-hot encoding can be good here + new_list_of_df = [] + for df in self: + df['hour'] = df['time'].apply(lambda x: int((str(x).split(' ')[1].split(':')[0]))) + df['day'] = df['time'].apply(lambda x: pd.Timestamp(str(x).split(' ')[0]).day_of_week) # or dayofweek + self.__list_of_df = new_list_of_df + def mean_sub_sample_data(self, sub_sample_rate): """ creates sub sampling according to the rate (if for example rate = 5, then every 5 samples, the one with the mean value is chosen to be in the data set). @param sub_sample_rate: """ + # todo: fix the bug where the "time" column is disappear new_list_of_df = [] for df in self: @@ -372,15 +382,11 @@ def main(): application_name="collector", path_to_data="../data/" ) - print("Plotting.") - print(dataset.sort_by_time()) - exit() - dataset.plot_not_random_dataset(number_of_samples=25) - print("Subsampling.") - exit() dataset.sub_sample_data(sub_sample_rate=10) print("Plotting.") dataset.plot_dataset(number_of_samples=3) + dataset.add_features() + exit() print("Normalizing.") dataset.scale_data() print("Plotting.") From 17bdb7ee8c18c0be42bd0e508353a0b7ab338496 Mon Sep 17 00:00:00 2001 From: koren Date: Sun, 6 Nov 2022 12:16:59 +0200 Subject: [PATCH 04/12] groupby shel hasmahot --- src/framework__data_set.py | 49 ++++++++++++++++++++++++++++------- src/framework_pytorch_lstm.py | 2 +- 2 files changed, 41 insertions(+), 10 deletions(-) diff --git a/src/framework__data_set.py b/src/framework__data_set.py index 04b9734..bb5d5ad 100644 --- a/src/framework__data_set.py +++ b/src/framework__data_set.py @@ -40,6 +40,9 @@ def __init__(self, list_of_df): ******************************************************************************************************************* """ + def get_list(self): + return self.__list_of_df + def __get_mean_and_std(self): """ calculates mean and std of all samples @@ -77,6 +80,11 @@ def sort_by_time(self): """ self.merge_df() self.merged_df = self.merged_df.sort_values(by="time") + self.merged_df = self.merged_df.groupby(['time'], as_index=False).max().reset_index() + + def get_marged(self): + return self.merged_df + def sub_sample_data(self, sub_sample_rate): """ @@ -134,7 +142,7 @@ def filter_data_that_is_too_short(self, data_length_limit): self.__list_of_df = new_list_of_df - def plot_dataset(self, number_of_samples): + def plot_dataset(self, number_of_samples, title): """ randomly selects samples from the data sets and plots . x-axis is time and y-axis is the value @param number_of_samples: number of randomly selected samples @@ -145,9 +153,30 @@ def plot_dataset(self, number_of_samples): ts = df["sample"].copy() ts.index = [time for time in df["time"]] ts.plot() + plt.ylabel(title) + plt.xlabel('time stamp') plt.show() + def plot_group(self): + """ + randomly selects samples from the data sets and plots . x-axis is time and y-axis is the value + @param number_of_samples: number of randomly selected samples + """ + df = self.merged_df + # plt.close("all") + ts = df["sample"].copy() + ts.index = [time for time in df["time"]] + f = plt.figure() + f.set_figwidth(20) + f.set_figheight(10) + ts.plot() + plt.ylabel("group plot") + plt.xlabel('time stamp') + plt.show() + + + def plot_not_random_dataset(self, number_of_samples): """ not randomly selects samples from the data sets and plots . x-axis is time and y-axis is the value @@ -382,22 +411,24 @@ def main(): application_name="collector", path_to_data="../data/" ) - dataset.sub_sample_data(sub_sample_rate=10) - print("Plotting.") - dataset.plot_dataset(number_of_samples=3) - dataset.add_features() + dataset.sort_by_time() + dataset.plot_group() exit() + + dataset.sub_sample_data(sub_sample_rate=5) + print("Plotting.") + dataset.plot_dataset(number_of_samples=3, title="Value before normalization") print("Normalizing.") dataset.scale_data() print("Plotting.") - dataset.plot_dataset(number_of_samples=3) + dataset.plot_dataset(number_of_samples=3, title="Value after normalization") print("Filtering time series that are too short.") - dataset.filter_data_that_is_too_short(data_length_limit=2 * length_to_predict) + dataset.filter_data_that_is_too_short(data_length_limit=30) print("Splitting.") train, test = dataset.split_to_train_and_test(length_to_predict=length_to_predict) print("Plotting.") - train.plot_dataset(number_of_samples=3) - test.plot_dataset(number_of_samples=3) + train.plot_dataset(number_of_samples=3, title="train value") + test.plot_dataset(number_of_samples=3, title="test value") else: hist = get_amount_of_data_per_application( metric="container_mem", diff --git a/src/framework_pytorch_lstm.py b/src/framework_pytorch_lstm.py index ad7287f..80f336b 100644 --- a/src/framework_pytorch_lstm.py +++ b/src/framework_pytorch_lstm.py @@ -107,7 +107,7 @@ def learn_from_data_set(self, training_data_set): self.__best_model = pytorch__driver_for_test_bench.train_neural_network( training_data_set=training_data_set, model=self.__model, - num_epochs=30, + num_epochs=10, model_input_length=self.__model_input_length, batch_size=64, criterion=self.__criterion, From 79b641a1b783d97a825cbf77afd10b1f2aae7194 Mon Sep 17 00:00:00 2001 From: koren Date: Wed, 14 Dec 2022 15:06:13 +0200 Subject: [PATCH 05/12] add filter zeros and filter extreme values --- src/framework__data_set.py | 44 +++++++++++++++++++++++++++++++++++--- 1 file changed, 41 insertions(+), 3 deletions(-) diff --git a/src/framework__data_set.py b/src/framework__data_set.py index bb5d5ad..13b43ae 100644 --- a/src/framework__data_set.py +++ b/src/framework__data_set.py @@ -142,6 +142,35 @@ def filter_data_that_is_too_short(self, data_length_limit): self.__list_of_df = new_list_of_df + + def filter_series_with_zeros(self): + """ + filters the data samples with zeros. + """ + new_list_of_df = [] + + for df in self: + # check if there is sample in the dataframe that contains some zero value + if not df.isin([0]).any().any(): + new_list_of_df.append(df) + + self.__list_of_df = new_list_of_df + + + def filter_series_extreme_values(self, n): + """ + filter the first and last element from every dataframe + """ + new_list_of_df = [] + + for df in self: + new_list_of_df.append(df.iloc[n:-n]) + assert len(new_list_of_df[-1]) == len(df) - 2*n + + + self.__list_of_df = new_list_of_df + + def plot_dataset(self, number_of_samples, title): """ randomly selects samples from the data sets and plots . x-axis is time and y-axis is the value @@ -408,13 +437,22 @@ def main(): print("Getting DataSet.") dataset = get_data_set( metric="container_cpu", - application_name="collector", + application_name="cni-plugins", path_to_data="../data/" ) - dataset.sort_by_time() - dataset.plot_group() + # dataset.sort_by_time() + # dataset.plot_group() + # exit() + + dataset.filter_data_that_is_too_short(data_length_limit=20) + dataset.filter_series_extreme_values(3) + dataset.plot_dataset(number_of_samples=20, title="Value before normalization") + print("number of series before filter zeros: ", len(dataset.get_list())) + dataset.filter_series_with_zeros() + print("number of series after filter zeros: ", len(dataset.get_list())) exit() + print("Splitting DataSet.") dataset.sub_sample_data(sub_sample_rate=5) print("Plotting.") dataset.plot_dataset(number_of_samples=3, title="Value before normalization") From 6c5623ccd3df8045f5126bfd9d3dfcb1f1b64af3 Mon Sep 17 00:00:00 2001 From: koren Date: Wed, 14 Dec 2022 20:19:23 +0200 Subject: [PATCH 06/12] build simple CNN --- src/cnn_time_series.py | 33 +++++++++++++++++++++++++++++++++ 1 file changed, 33 insertions(+) create mode 100644 src/cnn_time_series.py diff --git a/src/cnn_time_series.py b/src/cnn_time_series.py new file mode 100644 index 0000000..ea0c344 --- /dev/null +++ b/src/cnn_time_series.py @@ -0,0 +1,33 @@ +import torch.nn as nn +import torch.optim as optim +import numpy as np + +""" +creating CNN for time series prediction +""" + +class CNN(nn.Module): + def __init__(self, input_size, output_size): + super(CNN, self).__init__() + self.__seq_model = nn.Sequential( + nn.Conv1d(in_channels=input_size, out_channels=10, kernel_size=3, stride=1, padding=1), + nn.ReLU(), + nn.MaxPool1d(kernel_size=2), + nn.Conv1d(in_channels=10, out_channels=20, kernel_size=3, stride=1, padding=1), + nn.ReLU(), + nn.MaxPool1d(kernel_size=2), + nn.Flatten(), + nn.Linear(in_features=20*2, out_features=50), + nn.ReLU(), + nn.Linear(in_features=50, out_features=output_size) + ) + + def forward(self, x): + out = self.__seq_model(x) + return out + + def flatten_parameters(self): + pass + + + From 443f7169de3ed57f1c0f889a5c13b5e7a0b4d689 Mon Sep 17 00:00:00 2001 From: koren Date: Thu, 15 Dec 2022 18:23:50 +0200 Subject: [PATCH 07/12] the vanilla CNN is running --- src/cnn_time_series.py | 33 -------- src/framework__data_set.py | 2 + src/framework__test_bench.py | 12 ++- src/framework_pytorch_cnn.py | 110 ++++++++++++++++++++++++++ src/pytorch__driver_for_test_bench.py | 12 ++- 5 files changed, 134 insertions(+), 35 deletions(-) delete mode 100644 src/cnn_time_series.py create mode 100644 src/framework_pytorch_cnn.py diff --git a/src/cnn_time_series.py b/src/cnn_time_series.py deleted file mode 100644 index ea0c344..0000000 --- a/src/cnn_time_series.py +++ /dev/null @@ -1,33 +0,0 @@ -import torch.nn as nn -import torch.optim as optim -import numpy as np - -""" -creating CNN for time series prediction -""" - -class CNN(nn.Module): - def __init__(self, input_size, output_size): - super(CNN, self).__init__() - self.__seq_model = nn.Sequential( - nn.Conv1d(in_channels=input_size, out_channels=10, kernel_size=3, stride=1, padding=1), - nn.ReLU(), - nn.MaxPool1d(kernel_size=2), - nn.Conv1d(in_channels=10, out_channels=20, kernel_size=3, stride=1, padding=1), - nn.ReLU(), - nn.MaxPool1d(kernel_size=2), - nn.Flatten(), - nn.Linear(in_features=20*2, out_features=50), - nn.ReLU(), - nn.Linear(in_features=50, out_features=output_size) - ) - - def forward(self, x): - out = self.__seq_model(x) - return out - - def flatten_parameters(self): - pass - - - diff --git a/src/framework__data_set.py b/src/framework__data_set.py index 13b43ae..c328917 100644 --- a/src/framework__data_set.py +++ b/src/framework__data_set.py @@ -164,7 +164,9 @@ def filter_series_extreme_values(self, n): new_list_of_df = [] for df in self: + print(len(df)) new_list_of_df.append(df.iloc[n:-n]) + print(len(df.iloc[n:-n])) assert len(new_list_of_df[-1]) == len(df) - 2*n diff --git a/src/framework__test_bench.py b/src/framework__test_bench.py index 7623388..1d75879 100644 --- a/src/framework__test_bench.py +++ b/src/framework__test_bench.py @@ -6,6 +6,7 @@ import os import matplotlib.pyplot as plt +import torch import numpy as np import pandas as pd import time @@ -91,6 +92,14 @@ def __get_data(self, dictionary): dataset.sub_sample_data(sub_sample_rate=ss_rate) print(self.__msg, f"Throwing out data that is less than {dl_limit * ss_rate / 60} hours long.") dataset.filter_data_that_is_too_short(data_length_limit=dl_limit) + print(self.__msg, f"Cleaning zeros.") + dataset.filter_series_with_zeros() + print(self.__msg, f"Throwing out data that is less than {dl_limit * ss_rate / 60} hours long.") + dataset.filter_data_that_is_too_short(data_length_limit=dl_limit) + print(self.__msg, f"clean extreme values") + dataset.filter_series_extreme_values(1) + print(self.__msg, f"Throwing out data that is less than {dl_limit * ss_rate / 60} hours long.") + dataset.filter_data_that_is_too_short(data_length_limit=dl_limit) print(self.__msg, "Scaling data.") dataset.scale_data() print(self.__msg, "Splitting data into train and test.") @@ -101,7 +110,7 @@ def __get_data(self, dictionary): return train, test def __get_model(self, metric, app, train, test): - length_of_shortest_time_series = min([len(df) for df in train] + [len(df) for df in test]) + length_of_shortest_time_series = min([len(df) for df in train] + [len(df) for df in test]) # concatenate model = self.__class_to_test( length_of_shortest_time_series=length_of_shortest_time_series, metric=metric, @@ -249,6 +258,7 @@ def __test_model(self, test, model): total_mase = 0 total_mape = 0 for i, test_sample in enumerate(test): + mse_here, precision, recall, f1, mase, mape = self.__give_one_test_to_model( test_sample=test_sample, model=model, should_print=(i < 10) ) diff --git a/src/framework_pytorch_cnn.py b/src/framework_pytorch_cnn.py new file mode 100644 index 0000000..5dc2d01 --- /dev/null +++ b/src/framework_pytorch_cnn.py @@ -0,0 +1,110 @@ +import torch.nn as nn +import torch.optim as optim +import numpy as np +import pytorch__driver_for_test_bench as pytorch__driver_for_test_bench + +""" +creating CNN for time series prediction. +for now, we gonna set the Forecast Horizon to 1, for simplicity. +""" + + +class CNNPredictor(nn.Module): + def __init__(self, input_size, output_size, length_of_shortest_time_series): + super(CNNPredictor, self).__init__() + self.__length_of_shortest_time_series = length_of_shortest_time_series + # seq_length = input_size.shape[2] + self.__seq_model = nn.Sequential( + nn.Conv1d(in_channels=input_size, out_channels=1, kernel_size=3, stride=1, padding=0), + nn.ReLU(), + nn.MaxPool1d(kernel_size=2), + nn.Conv1d(in_channels=1, out_channels=1, kernel_size=3, stride=1, padding=0), + nn.ReLU(), + nn.MaxPool1d(kernel_size=2), + nn.Flatten(), + # the next line depends on the length of the minimal time series we need to change the 4 + # the 4 is because length of thr shortest time series is 23 and + # 23->21->10->8->4 (2 layers of conv1d and 2 layers of pooling operation) + nn.Linear(in_features=4, out_features=20), + nn.ReLU(), + nn.Linear(in_features=20, out_features=output_size) + ) + + def forward(self, x): + print(self.__length_of_shortest_time_series) + print(x.shape) + # use only the last "length_of_shortest_time_series" values of the time series + x = x[:, :, -1*self.__length_of_shortest_time_series:] + out = self.__seq_model(x) + return out + + def flatten_parameters(self): + pass + # self.__seq_model[0].flatten_parameters() + + +class PytorchCNNTester: + def __init__(self, length_of_shortest_time_series, metric, app): + # prepare parameters + self.__msg = "[PytorchCNNTester]" + self.__model_input_length = length_of_shortest_time_series // 2 + self.__model = CNNPredictor( + input_size=1, + output_size=1, + length_of_shortest_time_series=self.__model_input_length + ).to(pytorch__driver_for_test_bench.get_device()) + # Some Hyper-parameters + self.__optimizer = optim.Adam(self.__model.parameters(), lr=0.01) + self.__best_model = self.__model + self.__criterion = nn.MSELoss() + # prints + print(self.__msg, f"model = {self.__model}") + print(self.__msg, f"optimizer = {self.__optimizer}") + print(self.__msg, f"criterion = {self.__criterion}") + + + def learn_from_data_set(self, training_data_set): + self.__best_model = pytorch__driver_for_test_bench.train_neural_network( + training_data_set=training_data_set, + model=self.__model, + num_epochs=10, + model_input_length=self.__model_input_length, + batch_size=64, + criterion=self.__criterion, + optimizer=self.__optimizer + ) + + def predict(self, ts_as_df_start, how_much_to_predict): + # ignore if CNN ? + # self.__best_model.flatten_parameters() + return pytorch__driver_for_test_bench.predict( + ts_as_df_start=ts_as_df_start, how_much_to_predict=how_much_to_predict, best_model=self.__best_model + ) + + +""" +*********************************************************************************************************************** + main function +*********************************************************************************************************************** +""" + + +def main(test_to_perform): + import framework__test_bench as framework__test_bench + tb = framework__test_bench.TestBench( + class_to_test=PytorchCNNTester, + path_to_data="../data/", + tests_to_perform=test_to_perform + ) + tb.run_training_and_tests() + + +if __name__ == "__main__": + test_to_perform = ( + # Container CPU + {"metric": "container_cpu", "app": "collector", "prediction length": 5, "sub sample rate": 5, + "data length limit": 50}, + {"metric": "container_cpu", "app": "dns", "prediction length": 16, "sub sample rate": 30, + "data length limit": 30} + ) + main(test_to_perform) diff --git a/src/pytorch__driver_for_test_bench.py b/src/pytorch__driver_for_test_bench.py index e8218d6..4a6683a 100644 --- a/src/pytorch__driver_for_test_bench.py +++ b/src/pytorch__driver_for_test_bench.py @@ -92,15 +92,18 @@ def __prepare_batches(training_data_set, model_input_length, batch_size): ts_as_df["sample"].to_numpy() for ts_as_df in training_data_set ] + list_of_input_output_np_array = [ (arr[i: model_input_length + i], arr[model_input_length + i: model_input_length + i + 1]) for arr in list_of_np_array for i in range(len(arr) - model_input_length) ] - print(__msg, f"number of training samples = {len(list_of_input_output_np_array)}") + + # split all new TS into batches list_of_input_output_np_array_batched = __partition_list_to_batches( list_of_something=list_of_input_output_np_array, batch_size=batch_size ) + combined = __combine_batches_of_np_array(batches=list_of_input_output_np_array_batched) return combined @@ -114,6 +117,8 @@ def __prepare_batches(training_data_set, model_input_length, batch_size): def __do_batch(batch_data, optimizer, model, criterion): train_input, train_target = batch_data + #only for CNN + train_input = torch.transpose(train_input, 1, 2) optimizer.zero_grad() out = model.forward(x=train_input) loss = criterion(out, train_target) @@ -181,8 +186,13 @@ def predict(ts_as_df_start, how_much_to_predict, best_model): with torch.no_grad(): ts_as_np = ts_as_df_start["sample"].to_numpy() ts_as_tensor = __convert_np_array_to_pytorch_tensor(ts_as_np)[None, :, None].to(get_device()) + #if CNN for _ in range(how_much_to_predict): + # if CNN + ts_as_tensor = torch.transpose(ts_as_tensor, 1, 2) prediction = best_model.forward(ts_as_tensor) + # if CNN + ts_as_tensor = torch.transpose(ts_as_tensor, 1, 2) ts_as_tensor = torch.cat([ts_as_tensor, prediction[None, :]], dim=1) prediction_flattened = ts_as_tensor.view(how_much_to_predict + len(ts_as_df_start)).cpu() y = prediction_flattened.detach().numpy()[-how_much_to_predict:] From 8f561f1e24f8de35529b5fa7eed97d6509872e88 Mon Sep 17 00:00:00 2001 From: koren Date: Mon, 26 Dec 2022 18:44:04 +0200 Subject: [PATCH 08/12] working --- src/framework__test_bench.py | 4 +++- src/framework_pytorch_cnn.py | 31 ++++++++++++++++----------- src/framework_pytorch_lstm.py | 12 +++++++---- src/pytorch__driver_for_test_bench.py | 22 ++++++++++--------- 4 files changed, 42 insertions(+), 27 deletions(-) diff --git a/src/framework__test_bench.py b/src/framework__test_bench.py index 1d75879..b2614e9 100644 --- a/src/framework__test_bench.py +++ b/src/framework__test_bench.py @@ -51,8 +51,10 @@ def __init__( self, class_to_test, path_to_data, - tests_to_perform + tests_to_perform, + model_name = "CNN" ): + self.model_name = model_name self.__class_to_test = class_to_test self.__path_to_data = path_to_data for dictionary in tests_to_perform: diff --git a/src/framework_pytorch_cnn.py b/src/framework_pytorch_cnn.py index 5dc2d01..3645464 100644 --- a/src/framework_pytorch_cnn.py +++ b/src/framework_pytorch_cnn.py @@ -10,29 +10,33 @@ class CNNPredictor(nn.Module): - def __init__(self, input_size, output_size, length_of_shortest_time_series): + def __init__(self, input_size, output_size, length_of_shortest_time_series, pooling_size, kernel_size, num_of_filters): super(CNNPredictor, self).__init__() self.__length_of_shortest_time_series = length_of_shortest_time_series - # seq_length = input_size.shape[2] + self.pooling_size = pooling_size + self.kernel_size = kernel_size + self.num_of_filters = num_of_filters + fully_connected_features = num_of_filters**2 * np.floor((np.floor((length_of_shortest_time_series-kernel_size+1)/pooling_size)-kernel_size+1)/pooling_size) + fully_connected_features = int(fully_connected_features) + self.__seq_model = nn.Sequential( - nn.Conv1d(in_channels=input_size, out_channels=1, kernel_size=3, stride=1, padding=0), + nn.Conv1d(in_channels=input_size, out_channels=num_of_filters, kernel_size=kernel_size, stride=1, padding=0), nn.ReLU(), - nn.MaxPool1d(kernel_size=2), - nn.Conv1d(in_channels=1, out_channels=1, kernel_size=3, stride=1, padding=0), + nn.MaxPool1d(kernel_size=pooling_size), + nn.Conv1d(in_channels=num_of_filters, out_channels=num_of_filters**2, kernel_size=kernel_size, stride=1, padding=0), nn.ReLU(), - nn.MaxPool1d(kernel_size=2), + nn.MaxPool1d(kernel_size=pooling_size), nn.Flatten(), # the next line depends on the length of the minimal time series we need to change the 4 # the 4 is because length of thr shortest time series is 23 and # 23->21->10->8->4 (2 layers of conv1d and 2 layers of pooling operation) - nn.Linear(in_features=4, out_features=20), + + nn.Linear(in_features=fully_connected_features, out_features=20), nn.ReLU(), nn.Linear(in_features=20, out_features=output_size) ) def forward(self, x): - print(self.__length_of_shortest_time_series) - print(x.shape) # use only the last "length_of_shortest_time_series" values of the time series x = x[:, :, -1*self.__length_of_shortest_time_series:] out = self.__seq_model(x) @@ -44,8 +48,9 @@ def flatten_parameters(self): class PytorchCNNTester: - def __init__(self, length_of_shortest_time_series, metric, app): + def __init__(self, length_of_shortest_time_series, metric, app, model_name = "CNN"): # prepare parameters + self.model_name = model_name self.__msg = "[PytorchCNNTester]" self.__model_input_length = length_of_shortest_time_series // 2 self.__model = CNNPredictor( @@ -71,14 +76,16 @@ def learn_from_data_set(self, training_data_set): model_input_length=self.__model_input_length, batch_size=64, criterion=self.__criterion, - optimizer=self.__optimizer + optimizer=self.__optimizer, + model_name=self.model_name ) def predict(self, ts_as_df_start, how_much_to_predict): # ignore if CNN ? # self.__best_model.flatten_parameters() return pytorch__driver_for_test_bench.predict( - ts_as_df_start=ts_as_df_start, how_much_to_predict=how_much_to_predict, best_model=self.__best_model + ts_as_df_start=ts_as_df_start, how_much_to_predict=how_much_to_predict, best_model=self.__best_model, + model_name="CNN" ) diff --git a/src/framework_pytorch_lstm.py b/src/framework_pytorch_lstm.py index 80f336b..9890848 100644 --- a/src/framework_pytorch_lstm.py +++ b/src/framework_pytorch_lstm.py @@ -81,8 +81,9 @@ def flatten_parameters(self): class PytorchLSTMTester: - def __init__(self, length_of_shortest_time_series, metric, app): + def __init__(self, length_of_shortest_time_series, metric, app, model_name = "LSTM"): # prepare parameters + self.model_name = model_name self.__msg = "[PytorchLSTMTester]" self.__model_input_length = length_of_shortest_time_series // 2 self.__model = LSTMPredictor( @@ -111,13 +112,15 @@ def learn_from_data_set(self, training_data_set): model_input_length=self.__model_input_length, batch_size=64, criterion=self.__criterion, - optimizer=self.__optimizer + optimizer=self.__optimizer, + model_name=self.model_name, ) def predict(self, ts_as_df_start, how_much_to_predict): self.__best_model.flatten_parameters() return pytorch__driver_for_test_bench.predict( - ts_as_df_start=ts_as_df_start, how_much_to_predict=how_much_to_predict, best_model=self.__best_model + ts_as_df_start=ts_as_df_start, how_much_to_predict=how_much_to_predict, best_model=self.__best_model, + model_name = "LSTM" ) @@ -133,7 +136,8 @@ def main(test_to_perform): tb = framework__test_bench.TestBench( class_to_test=PytorchLSTMTester, path_to_data="../data/", - tests_to_perform=test_to_perform + tests_to_perform=test_to_perform, + model_name="LSTM", ) tb.run_training_and_tests() diff --git a/src/pytorch__driver_for_test_bench.py b/src/pytorch__driver_for_test_bench.py index 4a6683a..14acb9e 100644 --- a/src/pytorch__driver_for_test_bench.py +++ b/src/pytorch__driver_for_test_bench.py @@ -115,10 +115,11 @@ def __prepare_batches(training_data_set, model_input_length, batch_size): """ -def __do_batch(batch_data, optimizer, model, criterion): +def __do_batch(batch_data, optimizer, model, criterion, model_name): train_input, train_target = batch_data #only for CNN - train_input = torch.transpose(train_input, 1, 2) + if model_name == "CNN": + train_input = torch.transpose(train_input, 1, 2) optimizer.zero_grad() out = model.forward(x=train_input) loss = criterion(out, train_target) @@ -129,10 +130,10 @@ def __do_batch(batch_data, optimizer, model, criterion): return loss.item() -def __do_epoch(epoch_num, list_of_batch, training_data_set, optimizer, model, criterion): +def __do_epoch(epoch_num, list_of_batch, training_data_set, optimizer, model, criterion, model_name): sum_of_losses = 0 for i, batch_data in enumerate(list_of_batch): - loss = __do_batch(batch_data=batch_data, optimizer=optimizer, model=model, criterion=criterion) + loss = __do_batch(batch_data=batch_data, optimizer=optimizer, model=model, criterion=criterion, model_name=model_name) # print(__msg, f"loss of batch {i + 1} / {len(list_of_batch)}: {loss}") sum_of_losses += loss # choose random sample and plot @@ -153,7 +154,7 @@ def get_device(): def train_neural_network(training_data_set, model, num_epochs, model_input_length, batch_size, optimizer, criterion, - min_training_time_in_seconds=5): + model_name, min_training_time_in_seconds=5): list_of_batch = __prepare_batches( training_data_set=training_data_set, model_input_length=model_input_length, @@ -169,7 +170,7 @@ def train_neural_network(training_data_set, model, num_epochs, model_input_lengt epoch_start_time = time.time() sum_of_losses = __do_epoch( epoch_num=e, list_of_batch=list_of_batch, training_data_set=training_data_set, optimizer=optimizer, - model=model, criterion=criterion + model=model, criterion=criterion, model_name=model_name ) if sum_of_losses < min_sum_of_losses: min_sum_of_losses = sum_of_losses @@ -182,17 +183,18 @@ def train_neural_network(training_data_set, model, num_epochs, model_input_lengt return best_model -def predict(ts_as_df_start, how_much_to_predict, best_model): +def predict(ts_as_df_start, how_much_to_predict, best_model, model_name): with torch.no_grad(): ts_as_np = ts_as_df_start["sample"].to_numpy() ts_as_tensor = __convert_np_array_to_pytorch_tensor(ts_as_np)[None, :, None].to(get_device()) #if CNN for _ in range(how_much_to_predict): # if CNN - ts_as_tensor = torch.transpose(ts_as_tensor, 1, 2) + if model_name == "CNN": + ts_as_tensor = torch.transpose(ts_as_tensor, 1, 2) prediction = best_model.forward(ts_as_tensor) - # if CNN - ts_as_tensor = torch.transpose(ts_as_tensor, 1, 2) + if model_name == "CNN": + ts_as_tensor = torch.transpose(ts_as_tensor, 1, 2) ts_as_tensor = torch.cat([ts_as_tensor, prediction[None, :]], dim=1) prediction_flattened = ts_as_tensor.view(how_much_to_predict + len(ts_as_df_start)).cpu() y = prediction_flattened.detach().numpy()[-how_much_to_predict:] From 98369b4995bac408946bfbb23bfd1da8e2ba7353 Mon Sep 17 00:00:00 2001 From: koren Date: Wed, 28 Dec 2022 11:56:01 +0200 Subject: [PATCH 09/12] adding argsparse --- src/framework_pytorch_cnn.py | 96 ++++++++++++++++++++++++++++-------- 1 file changed, 76 insertions(+), 20 deletions(-) diff --git a/src/framework_pytorch_cnn.py b/src/framework_pytorch_cnn.py index 3645464..5a1a86c 100644 --- a/src/framework_pytorch_cnn.py +++ b/src/framework_pytorch_cnn.py @@ -8,6 +8,20 @@ for now, we gonna set the Forecast Horizon to 1, for simplicity. """ +import argparse + +parser = argparse.ArgumentParser() +parser.add_argument('--epochs', type=int, default=100, metavar='N', help='number of epochs') +parser.add_argument('--batch_size', type=int, default=64, metavar='N', help='batch size') +parser.add_argument('--save_num', type=int, default=7, metavar='N', help='number on the file to save') +parser.add_argument('--integers', metavar='N', type=int, nargs='+',help='lr decay') +parser.add_argument('--kernel', metavar='N', type=int, nargs='+',help='kernel sizes') +parser.add_argument('--filter_num', type=int, default=16, metavar='N', help='number of filters') +parser.add_argument('--pooling_size', type=int, default=1, metavar='N', help='number of filters') +parser.add_argument('--lr', type=int, default=0.001, metavar='N', help='learning rate') + +args = parser.parse_args() +print(args.kernel) class CNNPredictor(nn.Module): def __init__(self, input_size, output_size, length_of_shortest_time_series, pooling_size, kernel_size, num_of_filters): @@ -16,25 +30,67 @@ def __init__(self, input_size, output_size, length_of_shortest_time_series, pool self.pooling_size = pooling_size self.kernel_size = kernel_size self.num_of_filters = num_of_filters - fully_connected_features = num_of_filters**2 * np.floor((np.floor((length_of_shortest_time_series-kernel_size+1)/pooling_size)-kernel_size+1)/pooling_size) - fully_connected_features = int(fully_connected_features) - - self.__seq_model = nn.Sequential( - nn.Conv1d(in_channels=input_size, out_channels=num_of_filters, kernel_size=kernel_size, stride=1, padding=0), - nn.ReLU(), - nn.MaxPool1d(kernel_size=pooling_size), - nn.Conv1d(in_channels=num_of_filters, out_channels=num_of_filters**2, kernel_size=kernel_size, stride=1, padding=0), - nn.ReLU(), - nn.MaxPool1d(kernel_size=pooling_size), - nn.Flatten(), + + # calculate the first fully connected layer size + fully_connected_features = length_of_shortest_time_series + for i in range(len(kernel_size)): + fully_connected_features = np.floor((fully_connected_features-kernel_size[i]+1)/pooling_size) + fully_connected_features = num_of_filters * int(fully_connected_features) + + # build the model + for i in range(len(kernel_size)): + if i == 0: + self.__seq_model = nn.Sequential( + nn.Conv1d( + in_channels=input_size, + out_channels=num_of_filters, + kernel_size=kernel_size[i], + stride=1, + padding=0 + ), + nn.ReLU(), + nn.MaxPool1d(kernel_size=pooling_size), + ) + else: + self.__seq_model.add_module( + 'conv' + str(i), + module=nn.Conv1d( + in_channels=num_of_filters, + out_channels=num_of_filters, + kernel_size=kernel_size[i], + stride=1, + padding=0 + ) + + ) + self.__seq_model.add_module( + 'relu' + str(i), + module=nn.ReLU() + ) + self.__seq_model.add_module( + 'pool' + str(i), + module=nn.MaxPool1d(kernel_size=pooling_size) + ) + + self.__seq_model.add_module('flatten', nn.Flatten()) + self.__seq_model.add_module('linear1', module=nn.Linear(in_features=fully_connected_features, out_features=20)) + self.__seq_model.add_module('relu_after_linear1', module=nn.ReLU()) + self.__seq_model.add_module('linear2', module=nn.Linear(in_features=20, out_features=output_size)) + + # self.__seq_model = nn.Sequential( + # nn.Conv1d(in_channels=input_size, out_channels=num_of_filters, kernel_size=kernel_size, stride=1, padding=0), + # nn.ReLU(), + # nn.MaxPool1d(kernel_size=pooling_size), + # nn.Conv1d(in_channels=num_of_filters, out_channels=num_of_filters, kernel_size=kernel_size, stride=1, padding=0), + # nn.ReLU(), + # nn.MaxPool1d(kernel_size=pooling_size), + # nn.Flatten(), # the next line depends on the length of the minimal time series we need to change the 4 # the 4 is because length of thr shortest time series is 23 and # 23->21->10->8->4 (2 layers of conv1d and 2 layers of pooling operation) + # + - nn.Linear(in_features=fully_connected_features, out_features=20), - nn.ReLU(), - nn.Linear(in_features=20, out_features=output_size) - ) def forward(self, x): # use only the last "length_of_shortest_time_series" values of the time series @@ -44,7 +100,6 @@ def forward(self, x): def flatten_parameters(self): pass - # self.__seq_model[0].flatten_parameters() class PytorchCNNTester: @@ -56,10 +111,13 @@ def __init__(self, length_of_shortest_time_series, metric, app, model_name = "CN self.__model = CNNPredictor( input_size=1, output_size=1, - length_of_shortest_time_series=self.__model_input_length + length_of_shortest_time_series=self.__model_input_length, + pooling_size=args.pooling_size, + kernel_size=args.kernel, + num_of_filters=args.filter_num ).to(pytorch__driver_for_test_bench.get_device()) # Some Hyper-parameters - self.__optimizer = optim.Adam(self.__model.parameters(), lr=0.01) + self.__optimizer = optim.Adam(self.__model.parameters(), lr=0.001) self.__best_model = self.__model self.__criterion = nn.MSELoss() # prints @@ -81,8 +139,6 @@ def learn_from_data_set(self, training_data_set): ) def predict(self, ts_as_df_start, how_much_to_predict): - # ignore if CNN ? - # self.__best_model.flatten_parameters() return pytorch__driver_for_test_bench.predict( ts_as_df_start=ts_as_df_start, how_much_to_predict=how_much_to_predict, best_model=self.__best_model, model_name="CNN" From 30dc9328d9e0fe37f601e30533c8334ddb71349d Mon Sep 17 00:00:00 2001 From: koren Date: Sun, 19 Feb 2023 14:44:40 +0200 Subject: [PATCH 10/12] finito --- src/framework__data_set.py | 23 +------ src/framework__test_bench.py | 52 +++++++++++++--- src/framework_pytorch_cnn.py | 88 ++++++++++++++++----------- src/framework_pytorch_lstm.py | 6 +- src/pytorch__driver_for_test_bench.py | 9 ++- 5 files changed, 109 insertions(+), 69 deletions(-) diff --git a/src/framework__data_set.py b/src/framework__data_set.py index c328917..c062a69 100644 --- a/src/framework__data_set.py +++ b/src/framework__data_set.py @@ -12,9 +12,7 @@ from os import listdir from os.path import isfile, join import numpy as np -from darts.datasets import (AirPassengersDataset, MonthlyMilkDataset, - AusBeerDataset, GasRateCO2Dataset, WoolyDataset, ElectricityDataset) -# from darts.models.filtering.kalman_filter import KalmanFilter + """ *********************************************************************************************************************** @@ -413,25 +411,6 @@ def get_amount_of_data_per_application(metric, path_to_data): def main(): - # ts1 = AirPassengersDataset().load() - # ts2 = WoolyDataset().load() - # ts3 = AusBeerDataset().load() - # ts4 = GasRateCO2Dataset().load() - # ts5 = ElectricityDataset().load() - # ts6 = MonthlyMilkDataset().load() - # ts1.plot() - # plt.show() - # ts2.plot() - # plt.show() - # ts3.plot() - # plt.show() - # ts4.plot() - # plt.show() - # ts5.plot() - # plt.show() - # ts6.plot() - # plt.show() - # exit() print("Start.") length_to_predict = 4 test = 0 diff --git a/src/framework__test_bench.py b/src/framework__test_bench.py index b2614e9..f28bb9e 100644 --- a/src/framework__test_bench.py +++ b/src/framework__test_bench.py @@ -22,13 +22,18 @@ """ -def plot_result(original, prediction_as_np_array): +def plot_result(original, prediction_as_np_array, using): original_as_series = original["sample"].copy() predicted_as_series = pd.Series(prediction_as_np_array) x_axis = [time for time in original["time"]] original_as_series.index = x_axis - predicted_as_series.index = x_axis[-len(prediction_as_np_array):] + + # new_original_as_series = original_as_series[-(len(prediction_as_np_array)*2):] + # new_original_as_series.index = x_axis[-(len(prediction_as_np_array)*2):] + + predicted_as_series.index = x_axis[using:using+len(prediction_as_np_array)] ax = original_as_series.plot(color="blue", label="Samples") + # ax = new_original_as_series.plot(color="blue", label="Samples") predicted_as_series.plot(ax=ax, color="red", label="Predictions") plt.legend() plt.show() @@ -52,11 +57,13 @@ def __init__( class_to_test, path_to_data, tests_to_perform, - model_name = "CNN" + model_name = "CNN", + number_to_save = 1 ): self.model_name = model_name self.__class_to_test = class_to_test self.__path_to_data = path_to_data + self.number_to_save = number_to_save for dictionary in tests_to_perform: assert "metric" in dictionary assert "app" in dictionary @@ -193,28 +200,48 @@ def __give_one_test_to_model(self, test_sample, model, should_print): @return: mse, precision, recall, f1, mase of the test sample """ assert self.length_to_predict < len(test_sample) + + using = model.get_input_length() + assert using < len(test_sample) how_much_to_predict = self.length_to_predict how_much_to_give = len(test_sample) - how_much_to_predict + returned_ts_as_np_array = model.predict( - ts_as_df_start=test_sample[: how_much_to_give], - how_much_to_predict=how_much_to_predict - ) + ts_as_df_start=test_sample[: using], + how_much_to_predict=how_much_to_predict) + + first_returned_ts_as_np_array = returned_ts_as_np_array + + for i in range(1000): + if len(test_sample) <= using + how_much_to_predict*(i+2): + break + returned_ts_as_np_array = np.concatenate((returned_ts_as_np_array, model.predict( + ts_as_df_start=test_sample[: using + how_much_to_predict*(i+1)], + how_much_to_predict=how_much_to_predict + ))) + + # returned_ts_as_np_array = model.predict( + # ts_as_df_start=test_sample[: how_much_to_give], + # how_much_to_predict=how_much_to_predict + # ) # make sure the output is in the right format assert isinstance(returned_ts_as_np_array, np.ndarray) - assert len(returned_ts_as_np_array) == how_much_to_predict - assert returned_ts_as_np_array.shape == (how_much_to_predict,) + # assert len(returned_ts_as_np_array) == how_much_to_predict + # assert returned_ts_as_np_array.shape == (how_much_to_predict,) assert returned_ts_as_np_array.dtype == np.float64 # plot if needed if should_print: plot_result( original=test_sample, prediction_as_np_array=returned_ts_as_np_array, + using=using ) out_should_be = test_sample["sample"].to_numpy() mse_here, precision, recall, f1, mase, mape = self.__get_mse_precision_recall_f1_mase_and_mape( - y_true=out_should_be[how_much_to_give:], y_pred=returned_ts_as_np_array, + y_true=out_should_be[how_much_to_give:], y_pred=first_returned_ts_as_np_array, y_train=out_should_be[:how_much_to_give] ) + return mse_here, precision, recall, f1, mase, mape def __print_report(self, metric, app, mse, precision, recall, f1, training_time, mase, mape, as_table=False): @@ -231,6 +258,13 @@ def __print_report(self, metric, app, mse, precision, recall, f1, training_time, @param mape: @param as_table: whether to print as a table or not. """ + number = self.number_to_save + with open('results' + str(number) + '.txt', 'w') as f: + f.write("Average mse over the test set is = " + str(mse) + '\n' + "Average MASE over the test set is = " + str( + mase) + '\n' + "Average MAPE over the test set is = " + str(mape)) + # exit(0) + + if as_table: print(self.__msg, f"| {metric} | {app} | {round(training_time)} seconds | {round(mse, 5)} | {round(precision, 5)} | {round(recall, 5)} | {round(f1, 5)} | {round(mase, 5)} | {round(mape, 5)} |") diff --git a/src/framework_pytorch_cnn.py b/src/framework_pytorch_cnn.py index 5a1a86c..ae4b4f7 100644 --- a/src/framework_pytorch_cnn.py +++ b/src/framework_pytorch_cnn.py @@ -1,30 +1,43 @@ import torch.nn as nn import torch.optim as optim +import torch import numpy as np import pytorch__driver_for_test_bench as pytorch__driver_for_test_bench """ creating CNN for time series prediction. -for now, we gonna set the Forecast Horizon to 1, for simplicity. """ + + import argparse parser = argparse.ArgumentParser() -parser.add_argument('--epochs', type=int, default=100, metavar='N', help='number of epochs') +parser.add_argument('--epochs', type=int, default=30, metavar='N', help='number of epochs') parser.add_argument('--batch_size', type=int, default=64, metavar='N', help='batch size') -parser.add_argument('--save_num', type=int, default=7, metavar='N', help='number on the file to save') +parser.add_argument('--save_num', type=int, default=1, metavar='N', help='number on the file to save') parser.add_argument('--integers', metavar='N', type=int, nargs='+',help='lr decay') parser.add_argument('--kernel', metavar='N', type=int, nargs='+',help='kernel sizes') parser.add_argument('--filter_num', type=int, default=16, metavar='N', help='number of filters') -parser.add_argument('--pooling_size', type=int, default=1, metavar='N', help='number of filters') -parser.add_argument('--lr', type=int, default=0.001, metavar='N', help='learning rate') +parser.add_argument('--pooling_size', type=int, default=1, metavar='N', help='pooling size') +parser.add_argument('--lr', type=float, default=0.0001, metavar='N', help='learning rate') +parser.add_argument('--seed', type=int, default=0, metavar='N', help='seed') +parser.add_argument("--overparam", type=bool, default=False, help="more parameters") args = parser.parse_args() -print(args.kernel) + + +with open('params_' + str(args.save_num) + '.txt', 'w') as f: + f.write("epochs = "+str(args.epochs) + '\n' + "batch size = "+str(args.batch_size) + '\n' + "kernel = "+str(args.kernel) + + '\n' + "number of filter = "+str(args.filter_num) + '\n' + "pooling size = "+str(args.pooling_size) + '\n' + + "learning rate = "+str(args.lr) + '\n' + "lr decay at epochs: "+str(args.integers) + '\n' + "seed = "+str(args.seed)) + +np.random.seed(args.seed) +torch.manual_seed(args.seed) class CNNPredictor(nn.Module): - def __init__(self, input_size, output_size, length_of_shortest_time_series, pooling_size, kernel_size, num_of_filters): + def __init__(self, input_size, output_size, length_of_shortest_time_series, pooling_size, + kernel_size, num_of_filters, overparam=False): super(CNNPredictor, self).__init__() self.__length_of_shortest_time_series = length_of_shortest_time_series self.pooling_size = pooling_size @@ -73,23 +86,22 @@ def __init__(self, input_size, output_size, length_of_shortest_time_series, pool ) self.__seq_model.add_module('flatten', nn.Flatten()) - self.__seq_model.add_module('linear1', module=nn.Linear(in_features=fully_connected_features, out_features=20)) - self.__seq_model.add_module('relu_after_linear1', module=nn.ReLU()) - self.__seq_model.add_module('linear2', module=nn.Linear(in_features=20, out_features=output_size)) - - # self.__seq_model = nn.Sequential( - # nn.Conv1d(in_channels=input_size, out_channels=num_of_filters, kernel_size=kernel_size, stride=1, padding=0), - # nn.ReLU(), - # nn.MaxPool1d(kernel_size=pooling_size), - # nn.Conv1d(in_channels=num_of_filters, out_channels=num_of_filters, kernel_size=kernel_size, stride=1, padding=0), - # nn.ReLU(), - # nn.MaxPool1d(kernel_size=pooling_size), - # nn.Flatten(), - # the next line depends on the length of the minimal time series we need to change the 4 - # the 4 is because length of thr shortest time series is 23 and - # 23->21->10->8->4 (2 layers of conv1d and 2 layers of pooling operation) - # - + if not overparam: + self.__seq_model.add_module('linear1', module=nn.Linear(in_features=fully_connected_features, out_features=20)) + self.__seq_model.add_module('relu_after_linear1', module=nn.ReLU()) + self.__seq_model.add_module('linear2', module=nn.Linear(in_features=20, out_features=output_size)) + else: + self.__seq_model.add_module('linear1', module=nn.Linear(in_features=fully_connected_features, out_features=1500)) + self.__seq_model.add_module('relu_after_linear1', module=nn.ReLU()) + self.__seq_model.add_module('linear2', module=nn.Linear(in_features=1500, out_features=1000)) + self.__seq_model.add_module('relu_after_linear2', module=nn.ReLU()) + self.__seq_model.add_module('linear3', module=nn.Linear(in_features=1000, out_features=500)) + self.__seq_model.add_module('relu_after_linear3', module=nn.ReLU()) + self.__seq_model.add_module('linear4', module=nn.Linear(in_features=500, out_features=100)) + self.__seq_model.add_module('relu_after_linear4', module=nn.ReLU()) + self.__seq_model.add_module('linear5', module=nn.Linear(in_features=100, out_features=20)) + self.__seq_model.add_module('relu_after_linear5', module=nn.ReLU()) + self.__seq_model.add_module('linear6', module=nn.Linear(in_features=20, out_features=output_size)) def forward(self, x): @@ -114,10 +126,11 @@ def __init__(self, length_of_shortest_time_series, metric, app, model_name = "CN length_of_shortest_time_series=self.__model_input_length, pooling_size=args.pooling_size, kernel_size=args.kernel, - num_of_filters=args.filter_num + num_of_filters=args.filter_num, + overparam=args.overparam ).to(pytorch__driver_for_test_bench.get_device()) # Some Hyper-parameters - self.__optimizer = optim.Adam(self.__model.parameters(), lr=0.001) + self.__optimizer = optim.Adam(self.__model.parameters(), lr=args.lr) self.__best_model = self.__model self.__criterion = nn.MSELoss() # prints @@ -130,12 +143,14 @@ def learn_from_data_set(self, training_data_set): self.__best_model = pytorch__driver_for_test_bench.train_neural_network( training_data_set=training_data_set, model=self.__model, - num_epochs=10, + num_epochs=args.epochs, model_input_length=self.__model_input_length, - batch_size=64, + batch_size=args.batch_size, criterion=self.__criterion, optimizer=self.__optimizer, - model_name=self.model_name + model_name=self.model_name, + save_num=args.save_num, + lr_decay=args.integers ) def predict(self, ts_as_df_start, how_much_to_predict): @@ -144,6 +159,9 @@ def predict(self, ts_as_df_start, how_much_to_predict): model_name="CNN" ) + def get_input_length(self): + return self.__model_input_length + """ *********************************************************************************************************************** @@ -157,7 +175,9 @@ def main(test_to_perform): tb = framework__test_bench.TestBench( class_to_test=PytorchCNNTester, path_to_data="../data/", - tests_to_perform=test_to_perform + tests_to_perform=test_to_perform, + model_name="CNN", + number_to_save=args.save_num ) tb.run_training_and_tests() @@ -165,9 +185,9 @@ def main(test_to_perform): if __name__ == "__main__": test_to_perform = ( # Container CPU - {"metric": "container_cpu", "app": "collector", "prediction length": 5, "sub sample rate": 5, - "data length limit": 50}, - {"metric": "container_cpu", "app": "dns", "prediction length": 16, "sub sample rate": 30, - "data length limit": 30} + {"metric": "container_cpu", "app": "dns", "prediction length": 10, "sub sample rate": 5, + "data length limit": 60}, + {"metric": "container_cpu", "app": "dns", "prediction length": 10, "sub sample rate": 5, + "data length limit": 60} ) main(test_to_perform) diff --git a/src/framework_pytorch_lstm.py b/src/framework_pytorch_lstm.py index 9890848..92d1b42 100644 --- a/src/framework_pytorch_lstm.py +++ b/src/framework_pytorch_lstm.py @@ -108,7 +108,7 @@ def learn_from_data_set(self, training_data_set): self.__best_model = pytorch__driver_for_test_bench.train_neural_network( training_data_set=training_data_set, model=self.__model, - num_epochs=10, + num_epochs=9, model_input_length=self.__model_input_length, batch_size=64, criterion=self.__criterion, @@ -151,8 +151,8 @@ def main(test_to_perform): if __name__ == "__main__": test_to_perform = ( # Container CPU - {"metric": "container_cpu", "app": "collector", "prediction length": 5, "sub sample rate": 5, - "data length limit": 50}, + {"metric": "container_cpu", "app": "dns", "prediction length": 10, "sub sample rate": 5, + "data length limit": 60}, {"metric": "container_cpu", "app": "dns", "prediction length": 16, "sub sample rate": 30, "data length limit": 30} # {"metric": "container_cpu", "app": "collector", "prediction length": 16, "sub sample rate": 30, diff --git a/src/pytorch__driver_for_test_bench.py b/src/pytorch__driver_for_test_bench.py index 14acb9e..c85a2aa 100644 --- a/src/pytorch__driver_for_test_bench.py +++ b/src/pytorch__driver_for_test_bench.py @@ -12,6 +12,7 @@ import math import framework__test_bench as framework__test_bench import time +import torch.optim.lr_scheduler as lr_scheduler """ *********************************************************************************************************************** @@ -154,7 +155,7 @@ def get_device(): def train_neural_network(training_data_set, model, num_epochs, model_input_length, batch_size, optimizer, criterion, - model_name, min_training_time_in_seconds=5): + model_name, min_training_time_in_seconds=5, save_num=0, lr_decay=[]): list_of_batch = __prepare_batches( training_data_set=training_data_set, model_input_length=model_input_length, @@ -164,7 +165,10 @@ def train_neural_network(training_data_set, model, num_epochs, model_input_lengt training_start_time = time.time() min_sum_of_losses = float('inf') best_model = copy.deepcopy(model) + scheduler = lr_scheduler.ExponentialLR(optimizer, gamma=0.5) for e in range(99999999): + if e in lr_decay: + scheduler.step() if (e >= num_epochs) and (time.time() - training_start_time > min_training_time_in_seconds): break epoch_start_time = time.time() @@ -180,6 +184,9 @@ def train_neural_network(training_data_set, model, num_epochs, model_input_lengt epoch_time = epoch_stop_time - epoch_start_time avg_loss = sum_of_losses / len(list_of_batch) print(__msg, f"Epoch {e + 1} done. Epoch time was {epoch_time}. Average loss for the batches in epoch is {avg_loss}") + # save the model + torch.save(best_model.state_dict(), f"./weights" + str(save_num) + ".pth") + return best_model From d8ce35552c457ec0dc057f7b273cd57ba655c594 Mon Sep 17 00:00:00 2001 From: lidoravital Date: Sun, 19 Feb 2023 16:19:01 +0200 Subject: [PATCH 11/12] CNN notebook --- Notebooks/5_CNN.ipynb | 264 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 264 insertions(+) create mode 100644 Notebooks/5_CNN.ipynb diff --git a/Notebooks/5_CNN.ipynb b/Notebooks/5_CNN.ipynb new file mode 100644 index 0000000..f22ab93 --- /dev/null +++ b/Notebooks/5_CNN.ipynb @@ -0,0 +1,264 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "source": [ + "## **CNN MODEL**" + ], + "metadata": { + "id": "_sznVzsX-eUJ" + } + }, + { + "cell_type": "markdown", + "source": [ + "\n", + "-\tאגריגציה של time stamps לפי ערך מקסימלי.\n", + "-\tהתמודדות עם סדרות זמן בגדלים שונים- הפיכת כל הסדרות לאותו גודל (שנקבע על פי הגודל של הסדרה בעלת האורך המינימלי) באופן הבא: (מהמאמר שאיליה שלח) \n", + " ![time.png](data:image/png;base64,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)\n", + "-\tהפרמטרים שקבענו במודל CNN:\n", + "epochs = 50\n", + "batch size = 64\n", + "kernel = [7, 5, 3, 3] (4 convolution layers)\n", + "number of filter = 64\n", + "pooling size = 1\n", + "learning rate = 0.0001\n", + "Learning rate decay at epochs 5 and 10\n", + "Forecast horizon = 10\n", + "תוצאות חיזוי של CNN: \n", + "![prediction.png](data:image/png;base64,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)\n", + "-\tתובנות על CNN:\n", + " CNN הוא מודל שיודע ללמוד ולזהות תבניות מחזוריות. CNN יודע להסתכל על נקודות זמן שכנות ולהבין קשרים ביניהן.\n", + "כשלנתונים אין התנהגות ברורה,CNN בד\"כ ייקח את הממוצע.\n", + "\n" + ], + "metadata": { + "id": "3mnfkZMU-lR6" + } + }, + { + "cell_type": "markdown", + "source": [], + "metadata": { + "id": "V2b3qqv6-sE3" + } + }, + { + "cell_type": "code", + "source": [ + "import torch.nn as nn\n", + "import torch.optim as optim\n", + "import torch\n", + "import numpy as np\n", + "import pytorch__driver_for_test_bench as pytorch__driver_for_test_bench\n", + "\n", + "\"\"\"\n", + "creating CNN for time series prediction.\n", + "\"\"\"\n", + "\n", + "\n", + "\n", + "import argparse\n", + "\n", + "parser = argparse.ArgumentParser()\n", + "parser.add_argument('--epochs', type=int, default=30, metavar='N', help='number of epochs')\n", + "parser.add_argument('--batch_size', type=int, default=64, metavar='N', help='batch size')\n", + "parser.add_argument('--save_num', type=int, default=1, metavar='N', help='number on the file to save')\n", + "parser.add_argument('--integers', metavar='N', type=int, nargs='+',help='lr decay')\n", + "parser.add_argument('--kernel', metavar='N', type=int, nargs='+',help='kernel sizes')\n", + "parser.add_argument('--filter_num', type=int, default=16, metavar='N', help='number of filters')\n", + "parser.add_argument('--pooling_size', type=int, default=1, metavar='N', help='pooling size')\n", + "parser.add_argument('--lr', type=float, default=0.0001, metavar='N', help='learning rate')\n", + "parser.add_argument('--seed', type=int, default=0, metavar='N', help='seed')\n", + "parser.add_argument(\"--overparam\", type=bool, default=False, help=\"more parameters\")\n", + "\n", + "args = parser.parse_args()\n", + "\n", + "\n", + "with open('params_' + str(args.save_num) + '.txt', 'w') as f:\n", + " f.write(\"epochs = \"+str(args.epochs) + '\\n' + \"batch size = \"+str(args.batch_size) + '\\n' + \"kernel = \"+str(args.kernel)\n", + " + '\\n' + \"number of filter = \"+str(args.filter_num) + '\\n' + \"pooling size = \"+str(args.pooling_size) + '\\n'\n", + " + \"learning rate = \"+str(args.lr) + '\\n' + \"lr decay at epochs: \"+str(args.integers) + '\\n' + \"seed = \"+str(args.seed))\n", + "\n", + "np.random.seed(args.seed)\n", + "torch.manual_seed(args.seed)\n", + "\n", + "class CNNPredictor(nn.Module):\n", + " def __init__(self, input_size, output_size, length_of_shortest_time_series, pooling_size,\n", + " kernel_size, num_of_filters, overparam=False):\n", + " super(CNNPredictor, self).__init__()\n", + " self.__length_of_shortest_time_series = length_of_shortest_time_series\n", + " self.pooling_size = pooling_size\n", + " self.kernel_size = kernel_size\n", + " self.num_of_filters = num_of_filters\n", + "\n", + " # calculate the first fully connected layer size\n", + " fully_connected_features = length_of_shortest_time_series\n", + " for i in range(len(kernel_size)):\n", + " fully_connected_features = np.floor((fully_connected_features-kernel_size[i]+1)/pooling_size)\n", + " fully_connected_features = num_of_filters * int(fully_connected_features)\n", + "\n", + " # build the model\n", + " for i in range(len(kernel_size)):\n", + " if i == 0:\n", + " self.__seq_model = nn.Sequential(\n", + " nn.Conv1d(\n", + " in_channels=input_size,\n", + " out_channels=num_of_filters,\n", + " kernel_size=kernel_size[i],\n", + " stride=1,\n", + " padding=0\n", + " ),\n", + " nn.ReLU(),\n", + " nn.MaxPool1d(kernel_size=pooling_size),\n", + " )\n", + " else:\n", + " self.__seq_model.add_module(\n", + " 'conv' + str(i),\n", + " module=nn.Conv1d(\n", + " in_channels=num_of_filters,\n", + " out_channels=num_of_filters,\n", + " kernel_size=kernel_size[i],\n", + " stride=1,\n", + " padding=0\n", + " )\n", + "\n", + " )\n", + " self.__seq_model.add_module(\n", + " 'relu' + str(i),\n", + " module=nn.ReLU()\n", + " )\n", + " self.__seq_model.add_module(\n", + " 'pool' + str(i),\n", + " module=nn.MaxPool1d(kernel_size=pooling_size)\n", + " )\n", + "\n", + " self.__seq_model.add_module('flatten', nn.Flatten())\n", + " if not overparam:\n", + " self.__seq_model.add_module('linear1', module=nn.Linear(in_features=fully_connected_features, out_features=20))\n", + " self.__seq_model.add_module('relu_after_linear1', module=nn.ReLU())\n", + " self.__seq_model.add_module('linear2', module=nn.Linear(in_features=20, out_features=output_size))\n", + " else:\n", + " self.__seq_model.add_module('linear1', module=nn.Linear(in_features=fully_connected_features, out_features=1500))\n", + " self.__seq_model.add_module('relu_after_linear1', module=nn.ReLU())\n", + " self.__seq_model.add_module('linear2', module=nn.Linear(in_features=1500, out_features=1000))\n", + " self.__seq_model.add_module('relu_after_linear2', module=nn.ReLU())\n", + " self.__seq_model.add_module('linear3', module=nn.Linear(in_features=1000, out_features=500))\n", + " self.__seq_model.add_module('relu_after_linear3', module=nn.ReLU())\n", + " self.__seq_model.add_module('linear4', module=nn.Linear(in_features=500, out_features=100))\n", + " self.__seq_model.add_module('relu_after_linear4', module=nn.ReLU())\n", + " self.__seq_model.add_module('linear5', module=nn.Linear(in_features=100, out_features=20))\n", + " self.__seq_model.add_module('relu_after_linear5', module=nn.ReLU())\n", + " self.__seq_model.add_module('linear6', module=nn.Linear(in_features=20, out_features=output_size))\n", + "\n", + "\n", + " def forward(self, x):\n", + " # use only the last \"length_of_shortest_time_series\" values of the time series\n", + " x = x[:, :, -1*self.__length_of_shortest_time_series:]\n", + " out = self.__seq_model(x)\n", + " return out\n", + "\n", + " def flatten_parameters(self):\n", + " pass\n", + "\n", + "\n", + "class PytorchCNNTester:\n", + " def __init__(self, length_of_shortest_time_series, metric, app, model_name = \"CNN\"):\n", + " # prepare parameters\n", + " self.model_name = model_name\n", + " self.__msg = \"[PytorchCNNTester]\"\n", + " self.__model_input_length = length_of_shortest_time_series // 2\n", + " self.__model = CNNPredictor(\n", + " input_size=1,\n", + " output_size=1,\n", + " length_of_shortest_time_series=self.__model_input_length,\n", + " pooling_size=args.pooling_size,\n", + " kernel_size=args.kernel,\n", + " num_of_filters=args.filter_num,\n", + " overparam=args.overparam\n", + " ).to(pytorch__driver_for_test_bench.get_device())\n", + " # Some Hyper-parameters\n", + " self.__optimizer = optim.Adam(self.__model.parameters(), lr=args.lr)\n", + " self.__best_model = self.__model\n", + " self.__criterion = nn.MSELoss()\n", + " # prints\n", + " print(self.__msg, f\"model = {self.__model}\")\n", + " print(self.__msg, f\"optimizer = {self.__optimizer}\")\n", + " print(self.__msg, f\"criterion = {self.__criterion}\")\n", + "\n", + "\n", + " def learn_from_data_set(self, training_data_set):\n", + " self.__best_model = pytorch__driver_for_test_bench.train_neural_network(\n", + " training_data_set=training_data_set,\n", + " model=self.__model,\n", + " num_epochs=args.epochs,\n", + " model_input_length=self.__model_input_length,\n", + " batch_size=args.batch_size,\n", + " criterion=self.__criterion,\n", + " optimizer=self.__optimizer,\n", + " model_name=self.model_name,\n", + " save_num=args.save_num,\n", + " lr_decay=args.integers\n", + " )\n", + "\n", + " def predict(self, ts_as_df_start, how_much_to_predict):\n", + " return pytorch__driver_for_test_bench.predict(\n", + " ts_as_df_start=ts_as_df_start, how_much_to_predict=how_much_to_predict, best_model=self.__best_model,\n", + " model_name=\"CNN\"\n", + " )\n", + "\n", + " def get_input_length(self):\n", + " return self.__model_input_length\n", + "\n", + "\n", + "\"\"\"\n", + "***********************************************************************************************************************\n", + " main function\n", + "***********************************************************************************************************************\n", + "\"\"\"\n", + "\n", + "\n", + "def main(test_to_perform):\n", + " import framework__test_bench as framework__test_bench\n", + " tb = framework__test_bench.TestBench(\n", + " class_to_test=PytorchCNNTester,\n", + " path_to_data=\"../data/\",\n", + " tests_to_perform=test_to_perform,\n", + " model_name=\"CNN\",\n", + " number_to_save=args.save_num\n", + " )\n", + " tb.run_training_and_tests()\n", + "\n", + "\n", + "if __name__ == \"__main__\":\n", + " test_to_perform = (\n", + " # Container CPU\n", + " {\"metric\": \"container_cpu\", \"app\": \"dns\", \"prediction length\": 10, \"sub sample rate\": 5,\n", + " \"data length limit\": 60},\n", + " {\"metric\": \"container_cpu\", \"app\": \"dns\", \"prediction length\": 10, \"sub sample rate\": 5,\n", + " \"data length limit\": 60}\n", + " )\n", + " main(test_to_perform)\n" + ], + "metadata": { + "id": "G2yTadBY-edA" + }, + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file From dfb0ad05ef822021de50050d9d85a279fc1eb75b Mon Sep 17 00:00:00 2001 From: koren Date: Mon, 6 Mar 2023 11:33:43 +0200 Subject: [PATCH 12/12] add functions --- src/framework__test_bench.py | 153 +++++++++++++++++++++----- src/framework_pytorch_cnn.py | 11 +- src/pytorch__driver_for_test_bench.py | 99 ++++++++++++++--- 3 files changed, 213 insertions(+), 50 deletions(-) diff --git a/src/framework__test_bench.py b/src/framework__test_bench.py index f28bb9e..a3159b7 100644 --- a/src/framework__test_bench.py +++ b/src/framework__test_bench.py @@ -22,7 +22,7 @@ """ -def plot_result(original, prediction_as_np_array, using): +def plot_result_ongoing(original, prediction_as_np_array, using): original_as_series = original["sample"].copy() predicted_as_series = pd.Series(prediction_as_np_array) x_axis = [time for time in original["time"]] @@ -38,6 +38,17 @@ def plot_result(original, prediction_as_np_array, using): plt.legend() plt.show() +def plot_result(original, prediction_as_np_array): + original_as_series = original["sample"].copy() + predicted_as_series = pd.Series(prediction_as_np_array) + x_axis = [time for time in original["time"]] + original_as_series.index = x_axis + predicted_as_series.index = x_axis[-len(prediction_as_np_array):] + ax = original_as_series.plot(color="blue", label="Samples") + predicted_as_series.plot(ax=ax, color="red", label="Predictions") + plt.legend() + plt.show() + """ *********************************************************************************************************************** @@ -56,14 +67,10 @@ def __init__( self, class_to_test, path_to_data, - tests_to_perform, - model_name = "CNN", - number_to_save = 1 + tests_to_perform ): - self.model_name = model_name self.__class_to_test = class_to_test self.__path_to_data = path_to_data - self.number_to_save = number_to_save for dictionary in tests_to_perform: assert "metric" in dictionary assert "app" in dictionary @@ -83,6 +90,44 @@ def __init__( """ def __get_data(self, dictionary): + """ + @param dictionary: a specified test (keys are the definitions of the tests: the metrics, app name and more) + @return: train and test datasets + """ + metric = dictionary["metric"] + app = dictionary["app"] + ss_rate = dictionary["sub sample rate"] + dl_limit = dictionary["data length limit"] + self.length_to_predict = dictionary["prediction length"] + dataset = get_data_set( + metric=metric, + application_name=app, + path_to_data=self.__path_to_data + ) + print(self.__msg, f"Subsampling data from 1 sample per 1 minute to 1 sample per {ss_rate} minutes.") + dataset.sub_sample_data(sub_sample_rate=ss_rate) + print(self.__msg, f"Throwing out data that is less than {dl_limit * ss_rate / 60} hours long.") + dataset.filter_data_that_is_too_short(data_length_limit=dl_limit) + print(self.__msg, "Scaling data.") + dataset.scale_data() + print(self.__msg, "Splitting data into train and test.") + train, test = dataset.split_to_train_and_test(length_to_predict=self.length_to_predict) + assert len(train) == len(test) + assert min([len(df) for df in train] + [len(df) for df in test]) >= (dl_limit - self.length_to_predict) + print(self.__msg, f"Amount of train/test data is {len(train)}.") + return train, test + + def __get_model(self, metric, app, train, test): + length_of_shortest_time_series = min([len(df) for df in train] + [len(df) for df in test]) + model = self.__class_to_test( + length_of_shortest_time_series=length_of_shortest_time_series, + metric=metric, + app=app + ) + return model + + + def __get_data_CNN(self, dictionary): """ @param dictionary: a specified test (keys are the definitions of the tests: the metrics, app name and more) @return: train and test datasets @@ -119,7 +164,7 @@ def __get_data(self, dictionary): return train, test def __get_model(self, metric, app, train, test): - length_of_shortest_time_series = min([len(df) for df in train] + [len(df) for df in test]) # concatenate + length_of_shortest_time_series = min([len(df) for df in train] + [len(df) for df in test]) model = self.__class_to_test( length_of_shortest_time_series=length_of_shortest_time_series, metric=metric, @@ -127,6 +172,8 @@ def __get_model(self, metric, app, train, test): ) return model + + """ ******************************************************************************************************************* Model assessment @@ -191,9 +238,44 @@ def __get_mse_precision_recall_f1_mase_and_mape(y_true, y_pred, y_train): return mse_here, precision, recall, f1, mase, mape + def __give_one_test_to_model(self, test_sample, model, should_print): """ + @param test_sample: test sample + @param model: the model we're training + @param should_print: true if we want to plot + @return: mse, precision, recall, f1, mase of the test sample + """ + assert self.length_to_predict < len(test_sample) + how_much_to_predict = self.length_to_predict + how_much_to_give = len(test_sample) - how_much_to_predict + returned_ts_as_np_array = model.predict( + ts_as_df_start=test_sample[: how_much_to_give], + how_much_to_predict=how_much_to_predict + ) + # make sure the output is in the right format + assert isinstance(returned_ts_as_np_array, np.ndarray) + assert len(returned_ts_as_np_array) == how_much_to_predict + assert returned_ts_as_np_array.shape == (how_much_to_predict,) + assert returned_ts_as_np_array.dtype == np.float64 + # plot if needed + if should_print: + plot_result( + original=test_sample, + prediction_as_np_array=returned_ts_as_np_array, + ) + out_should_be = test_sample["sample"].to_numpy() + mse_here, precision, recall, f1, mase, mape = self.__get_mse_precision_recall_f1_mase_and_mape( + y_true=out_should_be[how_much_to_give:], y_pred=returned_ts_as_np_array, + y_train=out_should_be[:how_much_to_give] + ) + return mse_here, precision, recall, f1, mase, mape + + + def __give_one_test_to_model_CNN(self, test_sample, model, should_print): + """ + @param test_sample: test sample @param model: the model we're training @param should_print: true if we want to plot @@ -231,7 +313,7 @@ def __give_one_test_to_model(self, test_sample, model, should_print): assert returned_ts_as_np_array.dtype == np.float64 # plot if needed if should_print: - plot_result( + plot_result_ongoing( original=test_sample, prediction_as_np_array=returned_ts_as_np_array, using=using @@ -258,13 +340,6 @@ def __print_report(self, metric, app, mse, precision, recall, f1, training_time, @param mape: @param as_table: whether to print as a table or not. """ - number = self.number_to_save - with open('results' + str(number) + '.txt', 'w') as f: - f.write("Average mse over the test set is = " + str(mse) + '\n' + "Average MASE over the test set is = " + str( - mase) + '\n' + "Average MAPE over the test set is = " + str(mape)) - # exit(0) - - if as_table: print(self.__msg, f"| {metric} | {app} | {round(training_time)} seconds | {round(mse, 5)} | {round(precision, 5)} | {round(recall, 5)} | {round(f1, 5)} | {round(mase, 5)} | {round(mape, 5)} |") @@ -294,7 +369,6 @@ def __test_model(self, test, model): total_mase = 0 total_mape = 0 for i, test_sample in enumerate(test): - mse_here, precision, recall, f1, mase, mape = self.__give_one_test_to_model( test_sample=test_sample, model=model, should_print=(i < 10) ) @@ -333,6 +407,28 @@ def __do_one_test(self, dictionary): print(self.__msg, f"Done with metric='{metric}', app='{app}'") return mse, precision, recall, f1, training_time, mase, mape + + def __do_one_test_CNN(self, dictionary): + metric, app = dictionary["metric"], dictionary["app"] + print(self.__msg, f"Fetching data for metric='{metric}', app='{app}'.") + train, test = self.__get_data_CNN(dictionary=dictionary) + print(self.__msg, "Making an instance of the class we want to test.") + model = self.__get_model(metric=metric, app=app, train=train, test=test) + print(self.__msg, "Starting training loop.") + training_start_time = time.time() + model.learn_from_data_set(training_data_set=train) + training_stop_time = time.time() + training_time = training_stop_time - training_start_time + print(self.__msg, f"Training took {training_time} seconds.") + print(self.__msg, "Starting testing loop") + mse, precision, recall, f1, mase, mape = self.__test_model(test=test, model=model) + self.__print_report( + metric=metric, app=app, mse=mse, precision=precision, recall=recall, f1=f1, + training_time=training_time, mase=mase, mape=mape + ) + print(self.__msg, f"Done with metric='{metric}', app='{app}'") + return mse, precision, recall, f1, training_time, mase, mape + def print_device_information(self): print(self.__msg, "This test was run on:") import torch @@ -376,6 +472,21 @@ def run_training_and_tests(self): print(self.__msg, "Powering off test bench") + def run_training_and_tests_CNN(self): + print(self.__msg, "Powering on test bench") + full_report = [] + for dictionary in self.__tests_to_perform: + app = dictionary["app"] + metric = dictionary["metric"] + print(self.__msg, f"testing metric='{metric}', app='{app}'.") + mse, precision, recall, f1, training_time, mase, mape = self.__do_one_test_CNN(dictionary=dictionary) + full_report += [(mse, precision, recall, f1, training_time, mase, mape)] + assert len(full_report) == len(self.__tests_to_perform) + self.print_table_of_results(full_report=full_report) + # self.print_device_information() + print(self.__msg, "Powering off test bench") + + """ *********************************************************************************************************************** main function @@ -450,12 +561,4 @@ def main(test_to_perform): {"metric": "node_mem", "app": "emea/balrog", "prediction length": 16, "sub sample rate": 30, "data length limit": 30} ) - - real_test_to_perform = ( - # Container CPU - {"metric": "container_cpu", "app": "kube-rbac-proxy", "prediction length": 16, "sub sample rate": 10, - "data length limit": 80}, - {"metric": "container_cpu", "app": "dns", "prediction length": 16, "sub sample rate": 30, - "data length limit": 30}, - ) - main(real_test_to_perform) + main(test_to_perform) \ No newline at end of file diff --git a/src/framework_pytorch_cnn.py b/src/framework_pytorch_cnn.py index ae4b4f7..f34fdc9 100644 --- a/src/framework_pytorch_cnn.py +++ b/src/framework_pytorch_cnn.py @@ -140,7 +140,7 @@ def __init__(self, length_of_shortest_time_series, metric, app, model_name = "CN def learn_from_data_set(self, training_data_set): - self.__best_model = pytorch__driver_for_test_bench.train_neural_network( + self.__best_model = pytorch__driver_for_test_bench.train_neural_network_CNN( training_data_set=training_data_set, model=self.__model, num_epochs=args.epochs, @@ -148,13 +148,10 @@ def learn_from_data_set(self, training_data_set): batch_size=args.batch_size, criterion=self.__criterion, optimizer=self.__optimizer, - model_name=self.model_name, - save_num=args.save_num, - lr_decay=args.integers ) def predict(self, ts_as_df_start, how_much_to_predict): - return pytorch__driver_for_test_bench.predict( + return pytorch__driver_for_test_bench.predict_CNN( ts_as_df_start=ts_as_df_start, how_much_to_predict=how_much_to_predict, best_model=self.__best_model, model_name="CNN" ) @@ -176,10 +173,8 @@ def main(test_to_perform): class_to_test=PytorchCNNTester, path_to_data="../data/", tests_to_perform=test_to_perform, - model_name="CNN", - number_to_save=args.save_num ) - tb.run_training_and_tests() + tb.run_training_and_tests_CNN() if __name__ == "__main__": diff --git a/src/pytorch__driver_for_test_bench.py b/src/pytorch__driver_for_test_bench.py index c85a2aa..3f5f1ee 100644 --- a/src/pytorch__driver_for_test_bench.py +++ b/src/pytorch__driver_for_test_bench.py @@ -93,18 +93,15 @@ def __prepare_batches(training_data_set, model_input_length, batch_size): ts_as_df["sample"].to_numpy() for ts_as_df in training_data_set ] - list_of_input_output_np_array = [ (arr[i: model_input_length + i], arr[model_input_length + i: model_input_length + i + 1]) for arr in list_of_np_array for i in range(len(arr) - model_input_length) ] - - # split all new TS into batches + print(__msg, f"number of training samples = {len(list_of_input_output_np_array)}") list_of_input_output_np_array_batched = __partition_list_to_batches( list_of_something=list_of_input_output_np_array, batch_size=batch_size ) - combined = __combine_batches_of_np_array(batches=list_of_input_output_np_array_batched) return combined @@ -116,11 +113,21 @@ def __prepare_batches(training_data_set, model_input_length, batch_size): """ -def __do_batch(batch_data, optimizer, model, criterion, model_name): +def __do_batch(batch_data, optimizer, model, criterion): + train_input, train_target = batch_data + optimizer.zero_grad() + out = model.forward(x=train_input) + loss = criterion(out, train_target) + # loss_array[true_if_pad] = 0 + # loss = loss_array.sum() / false_if_pad.sum() + loss.backward() + optimizer.step() + return loss.item() + + +def __do_batch_CNN(batch_data, optimizer, model, criterion): train_input, train_target = batch_data - #only for CNN - if model_name == "CNN": - train_input = torch.transpose(train_input, 1, 2) + train_input = torch.transpose(train_input, 1, 2) optimizer.zero_grad() out = model.forward(x=train_input) loss = criterion(out, train_target) @@ -131,10 +138,10 @@ def __do_batch(batch_data, optimizer, model, criterion, model_name): return loss.item() -def __do_epoch(epoch_num, list_of_batch, training_data_set, optimizer, model, criterion, model_name): +def __do_epoch(epoch_num, list_of_batch, training_data_set, optimizer, model, criterion): sum_of_losses = 0 for i, batch_data in enumerate(list_of_batch): - loss = __do_batch(batch_data=batch_data, optimizer=optimizer, model=model, criterion=criterion, model_name=model_name) + loss = __do_batch(batch_data=batch_data, optimizer=optimizer, model=model, criterion=criterion) # print(__msg, f"loss of batch {i + 1} / {len(list_of_batch)}: {loss}") sum_of_losses += loss # choose random sample and plot @@ -143,6 +150,20 @@ def __do_epoch(epoch_num, list_of_batch, training_data_set, optimizer, model, cr return sum_of_losses +def __do_epoch_CNN(epoch_num, list_of_batch, training_data_set, optimizer, model, criterion): + sum_of_losses = 0 + for i, batch_data in enumerate(list_of_batch): + loss = __do_batch_CNN(batch_data=batch_data, optimizer=optimizer, model=model, criterion=criterion) + # print(__msg, f"loss of batch {i + 1} / {len(list_of_batch)}: {loss}") + sum_of_losses += loss + # choose random sample and plot + # if epoch_num % 5 == 0: + # __plot_prediction_of_random_sample(training_data_set=training_data_set, best_model=model) + return sum_of_losses + + + + """ ******************************************************************************************************************* API functions @@ -154,13 +175,14 @@ def get_device(): return torch.device("cuda:0" if torch.cuda.is_available() else "cpu") -def train_neural_network(training_data_set, model, num_epochs, model_input_length, batch_size, optimizer, criterion, - model_name, min_training_time_in_seconds=5, save_num=0, lr_decay=[]): +def train_neural_network_CNN(training_data_set, model, num_epochs, model_input_length, batch_size, optimizer, criterion, + min_training_time_in_seconds=5): list_of_batch = __prepare_batches( training_data_set=training_data_set, model_input_length=model_input_length, batch_size=batch_size ) + lr_decay = [10, 30] # change if needed epoch_time = 0 training_start_time = time.time() min_sum_of_losses = float('inf') @@ -172,9 +194,9 @@ def train_neural_network(training_data_set, model, num_epochs, model_input_lengt if (e >= num_epochs) and (time.time() - training_start_time > min_training_time_in_seconds): break epoch_start_time = time.time() - sum_of_losses = __do_epoch( + sum_of_losses = __do_epoch_CNN( epoch_num=e, list_of_batch=list_of_batch, training_data_set=training_data_set, optimizer=optimizer, - model=model, criterion=criterion, model_name=model_name + model=model, criterion=criterion ) if sum_of_losses < min_sum_of_losses: min_sum_of_losses = sum_of_losses @@ -184,13 +206,56 @@ def train_neural_network(training_data_set, model, num_epochs, model_input_lengt epoch_time = epoch_stop_time - epoch_start_time avg_loss = sum_of_losses / len(list_of_batch) print(__msg, f"Epoch {e + 1} done. Epoch time was {epoch_time}. Average loss for the batches in epoch is {avg_loss}") - # save the model - torch.save(best_model.state_dict(), f"./weights" + str(save_num) + ".pth") + return best_model + +def train_neural_network(training_data_set, model, num_epochs, model_input_length, batch_size, optimizer, criterion, + min_training_time_in_seconds=5): + list_of_batch = __prepare_batches( + training_data_set=training_data_set, + model_input_length=model_input_length, + batch_size=batch_size + ) + epoch_time = 0 + training_start_time = time.time() + min_sum_of_losses = float('inf') + best_model = copy.deepcopy(model) + for e in range(99999999): + if (e >= num_epochs) and (time.time() - training_start_time > min_training_time_in_seconds): + break + epoch_start_time = time.time() + sum_of_losses = __do_epoch( + epoch_num=e, list_of_batch=list_of_batch, training_data_set=training_data_set, optimizer=optimizer, + model=model, criterion=criterion + ) + if sum_of_losses < min_sum_of_losses: + min_sum_of_losses = sum_of_losses + best_model = copy.deepcopy(model) + assert not (best_model is model) # assert different objects + epoch_stop_time = time.time() + epoch_time = epoch_stop_time - epoch_start_time + avg_loss = sum_of_losses / len(list_of_batch) + print(__msg, f"Epoch {e + 1} done. Epoch time was {epoch_time}. Average loss for the batches in epoch is {avg_loss}") return best_model -def predict(ts_as_df_start, how_much_to_predict, best_model, model_name): +def predict(ts_as_df_start, how_much_to_predict, best_model): + with torch.no_grad(): + ts_as_np = ts_as_df_start["sample"].to_numpy() + ts_as_tensor = __convert_np_array_to_pytorch_tensor(ts_as_np)[None, :, None].to(get_device()) + for _ in range(how_much_to_predict): + prediction = best_model.forward(ts_as_tensor) + ts_as_tensor = torch.cat([ts_as_tensor, prediction[None, :]], dim=1) + prediction_flattened = ts_as_tensor.view(how_much_to_predict + len(ts_as_df_start)).cpu() + y = prediction_flattened.detach().numpy()[-how_much_to_predict:] + res = np.float64(y) + assert isinstance(res, np.ndarray) + assert len(res) == how_much_to_predict + assert res.shape == (how_much_to_predict,) + assert res.dtype == np.float64 + return res + +def predict_CNN(ts_as_df_start, how_much_to_predict, best_model, model_name='CNN'): with torch.no_grad(): ts_as_np = ts_as_df_start["sample"].to_numpy() ts_as_tensor = __convert_np_array_to_pytorch_tensor(ts_as_np)[None, :, None].to(get_device())