Add code

+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+import seaborn as sns
+from sklearn.metrics import accuracy_score, confusion_matrix, f1_score, recall_score
+
+from alibi_detect.od import SpectralResidual
+from alibi_detect.utils.perturbation import inject_outlier_ts
+from alibi_detect.utils.saving import save_detector, load_detector
+from alibi_detect.utils.visualize import plot_instance_score, plot_feature_outlier_ts
+import timesynth as ts
+
+n_points = 10000
+time_sampler = ts.TimeSampler(stop_time=n_points)
+time_samples = time_sampler.sample_regular_time(num_points=n_points)
+
+X = np.loadtxt("x_test.csv", delimiter=",", dtype=np.float32, encoding='UTF8', skiprows=1)
+Y = np.loadtxt("Y_test.csv", delimiter=",", dtype=np.float32, encoding='UTF8', skiprows=1)
+X = np.expand_dims(X, axis=1)
+
+data = inject_outlier_ts(X, perc_outlier=10, perc_window=10, n_std=2, min_std=1.)
+X_outlier, y_outlier, labels = data.data, data.target.astype(int), data.target_names
+
+
+od = SpectralResidual(
+    threshold=None,  # threshold for outlier score
+    window_amp=20,   # window for the average log amplitude
+    window_local=20, # window for the average saliency map
+    n_est_points=20  # nb of estimated points padded to the end of the sequence
+)
+
+X_threshold = X_outlier[:10000, :]
+
+od.infer_threshold(X_threshold, time_samples[:10000], threshold_perc=80)
+print('New threshold: {:.4f}'.format(od.threshold))
+
+od_preds = od.predict(X_outlier, time_samples, return_instance_score=True)
+
+a,TP,FP,FN = 0,0,0,0
+for i in range(10000):
+    if od_preds['data']['is_outlier'][i] == 0 and Y[i] == 0:
+        a +=1
+    if od_preds['data']['is_outlier'][i] == 1 and Y[i] == 1:
+        TP +=1
+    if od_preds['data']['is_outlier'][i] == 1 and Y[i] == 0:
+        FP +=1
+    if od_preds['data']['is_outlier'][i] == 0 and Y[i] == 1:
+        FN +=1
+
+print(a, TP, FP, FN)
+
+if TP == 0:
+    print("wrong model")
+else:
+    Precision = TP / (TP + FP)
+    Recall = TP / (TP + FN)
+    F1 = 2 * ((Precision * Recall) / (Precision + Recall))
+    print(Precision, Recall, F1)
+
+# y_pred = od_preds['data']['is_outlier']
+# f1 = f1_score(y_outlier, y_pred)
+# acc = accuracy_score(y_outlier, y_pred)
+# rec = recall_score(y_outlier, y_pred)
+# print('F1 score: {} -- Accuracy: {} -- Recall: {}'.format(f1, acc, rec))
+# cm = confusion_matrix(y_outlier, y_pred)
+# df_cm = pd.DataFrame(cm, index=labels, columns=labels)
+# sns.heatmap(df_cm, annot=True, cbar=True, linewidths=.5)
+# plt.show()
+
+# plot_feature_outlier_ts(od_preds,
+#                         X_outlier,
+#                         od.threshold,
+#                         window=(0, 200),
+#                         t=time_samples,
+#                         X_orig=X)
\ No newline at end of file

-import csv
-import numpy as np
-import torch
-from torch import nn
-from torch.autograd import Variable
-import torch.nn.functional as F
-
-# parameters
-num_epochs = 20
-window_size = 50
-batch_size = 128
-learning_rate = 1e-3
-threshold = 0.5
-
-# data load
-x_dataset = np.loadtxt("x_train.csv", delimiter=",", dtype=np.float32, encoding='UTF8', skiprows=1)
-y_dataset = np.loadtxt("x_test.csv", delimiter=",", dtype=np.float32, encoding='UTF8', skiprows=1)
-y_label = np.loadtxt("y_test.csv", delimiter=",", dtype=np.float32, encoding='UTF8', skiprows=1)
-
-# model: Simple-autoencoder
-class autoencoder(nn.Module):
-    def __init__(self):
-        super(autoencoder, self).__init__()
-        self.encoder = nn.Sequential(
-            nn.Linear(window_size, 128),
-            nn.ReLU(True),
-            nn.Linear(128, 64),
-            nn.ReLU(True), 
-            nn.Linear(64, 12), 
-            nn.ReLU(True), 
-            nn.Linear(12, 3)
-            )
-        self.decoder = nn.Sequential(
-            nn.Linear(3, 12),
-            nn.ReLU(True),
-            nn.Linear(12, 64),
-            nn.ReLU(True),
-            nn.Linear(64, 128),
-            nn.ReLU(True),
-            nn.Linear(128, window_size),
-            nn.Tanh()
-            )
-
-    def forward(self, x):
-        x = self.encoder(x)
-        x = self.decoder(x)
-        return x
-
-# model: Variational-autoencoder
-class VAE(nn.Module):
-    def __init__(self):
-        super(VAE, self).__init__()
-
-        self.fc1 = nn.Linear(window_size, 20)
-        self.fc2 = nn.Linear(20, 12)
-        self.fc31 = nn.Linear(12, 3)
-        self.fc32 = nn.Linear(12, 3)
-
-        self.fc4 = nn.Linear(3, 12)
-        self.fc5 = nn.Linear(12, 20)
-        self.fc6 = nn.Linear(20, window_size)
-
-    def encode(self, x):
-        h1 = F.relu(self.fc1(x))
-        h2 = F.relu(self.fc2(h1))
-        return self.fc31(h2), self.fc32(h2)
-
-    def reparametrize(self, mu, logvar):
-        std = logvar.mul(0.5).exp_()
-        if torch.cuda.is_available():
-            eps = torch.cuda.FloatTensor(std.size()).normal_()
-        else:
-            eps = torch.FloatTensor(std.size()).normal_()
-        eps = Variable(eps)
-        return eps.mul(std).add_(mu)
-
-    def decode(self, z):
-        h3 = F.relu(self.fc4(z))
-        h4 = F.relu(self.fc5(h3))
-        return F.sigmoid(self.fc6(h4))
-
-    def forward(self, x):
-        mu, logvar = self.encode(x)
-        z = self.reparametrize(mu, logvar)
-        return self.decode(z), mu, logvar
-
-# loss function for VAE
-reconstruction_function = nn.MSELoss(size_average=False)
-def loss_function(recon_x, x, mu, logvar):
-    """
-    recon_x: generating images
-    x: origin images
-    mu: latent mean
-    logvar: latent log variance
-    """
-    BCE = reconstruction_function(recon_x, x)  # mse loss
-    # loss = 0.5 * sum(1 + log(sigma^2) - mu^2 - sigma^2)
-    KLD_element = mu.pow(2).add_(logvar.exp()).mul_(-1).add_(1).add_(logvar)
-    KLD = torch.sum(KLD_element).mul_(-0.5)
-    # KL divergence
-    return BCE + KLD
-
-
-model = VAE()
-criterion = nn.MSELoss()
-optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate, weight_decay=1e-3)
-
-# train
-for epoch in range(num_epochs):
-    model.train()
-    train_loss = 0
-    for idx in range(0, len(x_dataset)-batch_size+1, batch_size):
-        data = []
-        for i in range(batch_size):
-            datum = x_dataset[idx + i: idx + i + window_size]
-            if(len(datum) != window_size): # 마지막 부분 window_size만큼의 데이터가 없는 경우 0 추가
-                for _ in range(window_size - len(datum)):
-                    datum = np.append(datum, 0)
-            data.append(datum)
-        data = torch.FloatTensor(data)
-
-        optimizer.zero_grad()
-        recon_batch, mu, logvar = model(data)
-        loss = loss_function(recon_batch, data, mu, logvar)
-        loss.backward()
-        train_loss += loss.item()
-        optimizer.step()
-
-    print('====> Epoch: {} Average loss: {:.4f}'.format(
-        epoch, train_loss / len(x_dataset)))
-
-# evaluation
-TP = 0
-FP = 0
-FN = 0
-f = open('result.csv', 'w', encoding='utf-8', newline='')
-wr = csv.writer(f)
-wr.writerow(["index", "loss", "label"])
-for idx in range(len(y_dataset)-window_size+1):
-    with torch.no_grad():
-        data = y_dataset[idx:idx+window_size]
-        data = torch.FloatTensor(data).unsqueeze(0)
-
-        recon_batch, mu, logvar = model(data)
-        loss = loss_function(recon_batch, data, mu, logvar)
-
-        wr.writerow([idx, loss.item(), y_label[idx+window_size-1]])
-
-        if(loss.item() >= threshold):
-            predict = 1
-        else:
-            predict = 0
-
-        if(predict == 1 and y_label[idx+window_size-1] == 1):
-            TP += 1
-        elif(predict == 1 and y_label[idx+window_size-1] == 0):
-            FP += 1
-        elif(predict == 0 and y_label[idx+window_size-1] == 1):
-            FN += 1
-
-# precision = TP / (TP + FP)
-# recall = TP / (TP + FN)
-# F1 = 2 * (precision * recall) / (precision + recall)
-
-# print("precision: ", precision)
-# print("recall: ", recall)
-# print("F1: ", F1)
\ No newline at end of file

+import csv
+import numpy as np
+import torch
+from torch import nn
+from torch.autograd import Variable
+import torch.nn.functional as F
+
+# parameters
+num_epochs = 2
+window_size = 16
+batch_size = 128
+learning_rate = 1e-3
+
+# data load
+x_dataset = np.loadtxt("x_train.csv", delimiter=",", dtype=np.float32, encoding='UTF8', skiprows=1)
+x_label = np.loadtxt("y_train.csv", delimiter=",", dtype=np.float32, encoding='UTF8', skiprows=1)
+y_dataset = np.loadtxt("x_test.csv", delimiter=",", dtype=np.float32, encoding='UTF8', skiprows=1)
+y_label = np.loadtxt("y_test.csv", delimiter=",", dtype=np.float32, encoding='UTF8', skiprows=1)
+
+# model: Simple-autoencoder
+class autoencoder(nn.Module):
+    def __init__(self):
+        super(autoencoder, self).__init__()
+        self.encoder = nn.Sequential(
+            nn.Linear(window_size, 20),
+            nn.ReLU(True),
+            nn.Linear(20, 12),
+            nn.ReLU(True), 
+            nn.Linear(12, 3), 
+            )
+        self.decoder = nn.Sequential(
+            nn.Linear(3, 12),
+            nn.ReLU(True),
+            nn.Linear(12, 20),
+            nn.ReLU(True),
+            nn.Linear(20, window_size),
+            nn.Tanh()
+            )
+
+    def forward(self, x):
+        x = self.encoder(x)
+        x = self.decoder(x)
+        return x
+
+# model: CNN-autoencoder
+class CNNautoencoder(nn.Module):
+    def __init__(self):
+        super(CNNautoencoder, self).__init__()
+        self.encoder = nn.Sequential(
+            nn.Conv1d(1, 8, kernel_size=3, stride=3, padding=1),
+            nn.ReLU(True),
+            nn.MaxPool1d(2, stride=2),
+            nn.Conv1d(8, 4, kernel_size=3, stride=1, padding=0)
+        )
+        self.decoder = nn.Sequential(
+            nn.ConvTranspose1d(4, 8, kernel_size=3, stride=1),
+            nn.ReLU(True),
+            nn.ConvTranspose1d(8, 4, kernel_size=2, stride=2, padding=0),
+            nn.ReLU(True),
+            nn.ConvTranspose1d(4, 1, kernel_size=3, stride=3, padding=1),
+            nn.Tanh()
+        )
+
+    def forward(self, x):
+        x = self.encoder(x)
+        x = self.decoder(x)
+        return x
+
+# model: Variational-autoencoder(VAE)
+class VAE(nn.Module):
+    def __init__(self):
+        super(VAE, self).__init__()
+
+        self.fc1 = nn.Linear(window_size, 12)
+        self.fc21 = nn.Linear(12, 3)
+        self.fc22 = nn.Linear(12, 3)
+        # self.fc32 = nn.Linear(12, 3)
+
+        self.fc3 = nn.Linear(3, 12)
+        # self.fc4 = nn.Linear(12, 20)
+        self.fc4 = nn.Linear(12, window_size)
+
+    def encode(self, x):
+        h1 = F.relu(self.fc1(x))
+        # h2 = F.relu(self.fc2(h1))
+        return self.fc21(h1), self.fc22(h1)
+
+    def reparametrize(self, mu, logvar):
+        std = logvar.mul(0.5).exp_()
+        if torch.cuda.is_available():
+            eps = torch.cuda.FloatTensor(std.size()).normal_()
+        else:
+            eps = torch.FloatTensor(std.size()).normal_()
+        eps = Variable(eps)
+        return eps.mul(std).add_(mu)
+
+    def decode(self, z):
+        h3 = F.relu(self.fc3(z))
+        # h4 = F.relu(self.fc5(h3))
+        return F.sigmoid(self.fc4(h3))
+
+    def forward(self, x):
+        mu, logvar = self.encode(x)
+        z = self.reparametrize(mu, logvar)
+        return self.decode(z), mu, logvar
+
+# loss function for VAE
+reconstruction_function = nn.MSELoss(size_average=False)
+def loss_function(recon_x, x, mu, logvar):
+    """
+    recon_x: generating images
+    x: origin images
+    mu: latent mean
+    logvar: latent log variance
+    """
+    BCE = reconstruction_function(recon_x, x)  # mse loss
+    # loss = 0.5 * sum(1 + log(sigma^2) - mu^2 - sigma^2)
+    KLD_element = mu.pow(2).add_(logvar.exp()).mul_(-1).add_(1).add_(logvar)
+    KLD = torch.sum(KLD_element).mul_(-0.5)
+    # KL divergence
+    return BCE + KLD
+
+# F1 loss function
+class F1_Loss(nn.Module):
+    def __init__(self, epsilon=1e-7):
+        super().__init__()
+        self.epsilon = epsilon
+        
+    def forward(self, y_pred, y_true,):
+        assert y_pred.ndim == 2
+        # assert y_true.ndim == 1
+        # y_true = F.one_hot(y_true, 2).to(torch.float32)
+        y_pred = F.softmax(y_pred, dim=1)
+        
+        tp = (y_true * y_pred).sum(dim=0).to(torch.float32)
+        tn = ((1 - y_true) * (1 - y_pred)).sum(dim=0).to(torch.float32)
+        fp = ((1 - y_true) * y_pred).sum(dim=0).to(torch.float32)
+        fn = (y_true * (1 - y_pred)).sum(dim=0).to(torch.float32)
+
+        precision = tp / (tp + fp + self.epsilon)
+        recall = tp / (tp + fn + self.epsilon)
+
+        f1 = 2* (precision*recall) / (precision + recall + self.epsilon)
+        f1 = f1.clamp(min=self.epsilon, max=1-self.epsilon)
+        return 1 - f1.mean()
+
+# model: MLP
+class MLP(nn.Module):
+    def __init__(self):
+        super(MLP, self).__init__()
+        self.fc1 = nn.Linear(window_size, 16)
+        self.fc2 = nn.Linear(16, 4)
+        self.fc3 = nn.Linear(4, 2)
+
+    def forward(self, x):
+        x = F.relu(self.fc1(x))
+        x = F.relu(self.fc2(x))
+        return F.softmax(self.fc3(x))
+
+# model: LSTM-autoencoder
+class LSTMautoencoder(nn.Module):
+    def __init__(self):
+        super(LSTMautoencoder, self).__init__()
+        self.lstm1 = nn.LSTM(16, 4)
+        self.relu = nn.ReLU(True)
+        self.lstm2 = nn.LSTM(4,16)
+        self.tanh = nn.Tanh()
+
+
+    def forward(self, x):
+        x = self.relu(self.lstm1(x)[0])
+        x = self.tanh(self.lstm2(x)[0])
+        return x
+
+
+
+# train for VAE
+def train_VAE():
+    for epoch in range(num_epochs):
+        model.train()
+        train_loss = 0
+        for idx in range(0, len(x_dataset)-batch_size+1, batch_size):
+            data = []
+            for i in range(batch_size):
+                datum = x_dataset[idx + i: idx + i + window_size]
+                if(len(datum) != window_size): # 마지막 부분 window_size만큼의 데이터가 없는 경우 0 추가
+                    for _ in range(window_size - len(datum)):
+                        datum = np.append(datum, 0)
+                data.append(datum)
+            data = torch.FloatTensor(data)
+
+            optimizer.zero_grad()
+            recon_batch, mu, logvar = model(data)
+            loss = loss_function(recon_batch, data, mu, logvar)
+            loss.backward()
+            train_loss += loss.item()
+            optimizer.step()
+
+        print('====> Epoch: {} Average loss: {:.4f}'.format(
+            epoch, train_loss / len(x_dataset)))
+
+# evaluation for VAE
+def evaluation_VAE():
+    f = open('result.csv', 'w', encoding='utf-8', newline='')
+    wr = csv.writer(f)
+    wr.writerow(["index", "loss", "label"])
+    for idx in range(len(y_dataset)-window_size+1):
+        with torch.no_grad():
+            data = y_dataset[idx:idx+window_size]
+            data = torch.FloatTensor(data).unsqueeze(0)
+            recon_batch, mu, logvar = model(data)
+            loss = loss_function(recon_batch, data, mu, logvar)
+            wr.writerow([idx, loss.item(), y_label[idx+int(window_size/2)]])
+
+# train for CNNautoencoder
+def train_CNNautoencoder():
+    for epoch in range(num_epochs):
+        model.train()
+        train_loss = 0
+        for idx in range(0, len(x_dataset)-batch_size+1, batch_size):
+            data = []
+            for i in range(batch_size):
+                datum = x_dataset[idx + i: idx + i + window_size]
+                if(len(datum) != window_size): # 마지막 부분 window_size만큼의 데이터가 없는 경우 0 추가
+                    for _ in range(window_size - len(datum)):
+                        datum = np.append(datum, 0)
+                data.append(np.expand_dims(datum, 0))
+            data = torch.FloatTensor(data)
+
+            optimizer.zero_grad()
+            output = model(data)
+            loss = criterion(output, data)
+            loss.backward()
+            train_loss += loss.item()
+            optimizer.step()
+
+        print('====> Epoch: {} Average loss: {:.4f}'.format(
+            epoch, train_loss / len(x_dataset)))
+
+# evaluation for CNNautoencoder
+def evaluation_CNNautoencoder():
+    f = open('result.csv', 'w', encoding='utf-8', newline='')
+    wr = csv.writer(f)
+    wr.writerow(["index", "loss", "label"])
+    for idx in range(len(y_dataset)-window_size+1):
+        with torch.no_grad():
+            data = y_dataset[idx:idx+window_size]
+            data = torch.FloatTensor(data).unsqueeze(0).unsqueeze(0)
+            output = model(data)
+            loss = criterion(output, data)
+            wr.writerow([idx, loss.item(), y_label[idx+int(window_size/2)]])
+
+# train for autoencoder
+def train_autoencoder():
+    for epoch in range(num_epochs):
+        model.train()
+        train_loss = 0
+        for idx in range(0, len(x_dataset)-batch_size+1, batch_size):
+            data = []
+            for i in range(batch_size):
+                datum = x_dataset[idx + i: idx + i + window_size]
+                if(len(datum) != window_size): # 마지막 부분 window_size만큼의 데이터가 없는 경우 0 추가
+                    for _ in range(window_size - len(datum)):
+                        datum = np.append(datum, 0)
+                data.append(datum, 0)
+            data = torch.FloatTensor(data)
+
+            optimizer.zero_grad()
+            output = model(data)
+            loss = criterion(output, data)
+            loss.backward()
+            train_loss += loss.item()
+            optimizer.step()
+
+        print('====> Epoch: {} Average loss: {:.4f}'.format(
+            epoch, train_loss / len(x_dataset)))
+
+# evaluation for autoencoder
+def evaluation_autoencoder():
+    f = open('result.csv', 'w', encoding='utf-8', newline='')
+    wr = csv.writer(f)
+    wr.writerow(["index", "loss", "label"])
+    for idx in range(len(y_dataset)-window_size+1):
+        with torch.no_grad():
+            data = y_dataset[idx:idx+window_size]
+            data = torch.FloatTensor(data).unsqueeze(0)
+            output = model(data)
+            loss = criterion(output, data)
+            wr.writerow([idx, loss.item(), y_label[idx+int(window_size/2)]])
+
+# train for MLP
+def train_MLP():
+    for epoch in range(num_epochs):
+        model.train()
+        train_loss = 0
+        for idx in range(0, len(x_dataset)-batch_size+1, batch_size):
+            data = []
+            target = []
+            for i in range(batch_size):
+                datum = x_dataset[idx + i : idx + i + window_size]
+                if(len(datum) != window_size): # 마지막 부분 window_size만큼의 데이터가 없는 경우 0 추가
+                    for _ in range(window_size - len(datum)):
+                        datum = np.append(datum, 0)
+                data.append(datum)
+
+                a_target = x_label[idx + i + int(window_size/2) : idx + i + int(window_size/2)]
+                if(len(a_target) == 0):
+                    a_target = 0.0
+                if(a_target == 0):
+                    a_target = [1.0, 0.0]
+                else:
+                    a_target = [0.0, 1.0]
+                target.append(a_target)
+
+            data = torch.FloatTensor(data)
+            target = torch.FloatTensor(target)
+
+            optimizer.zero_grad()
+            predict = model(data)
+            loss = criterion(predict, target)
+            train_loss += loss.item()
+            loss.backward()
+            optimizer.step()
+
+        print('====> Epoch: {} Average loss: {:.4f}'.format(
+            epoch, train_loss / len(x_dataset)))
+
+# evaluation for MLP
+def evaluation_MLP():
+    f = open('result.csv', 'w', encoding='utf-8', newline='')
+    wr = csv.writer(f)
+    wr.writerow(["index", "prediction", "label"])
+    for idx in range(len(y_dataset)-window_size+1):
+        with torch.no_grad():
+            data = y_dataset[idx:idx+window_size]
+            data = torch.FloatTensor(data).unsqueeze(0)
+            prediction = model(data).max()
+            wr.writerow([idx, prediction.item(), y_label[idx+int(window_size/2)]])
+
+
+##########################################################
+# main
+model = LSTMautoencoder()
+criterion = nn.MSELoss() # VAE일 경우 무시
+optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate, weight_decay=1e-3)
+
+train_CNNautoencoder()
+evaluation_CNNautoencoder()
\ No newline at end of file

+from fbprophet import Prophet
+from fbprophet.plot import plot_yearly
+import pandas as pd
+import matplotlib.pyplot as plt
+import time
+
+def detect_anomalies(forecast, new_df):
+    forecasted = forecast[['trend', 'yhat', 'yhat_lower', 'yhat_upper']].copy()
+    forecasted['fact'] = new_df['y']
+    forecasted['ds'] = new_df['ds']
+
+    forecasted['anomaly'] = 0
+
+    forecasted.loc[forecasted['fact'] > forecasted['yhat_upper'], 'anomaly'] = 1
+    forecasted.loc[forecasted['fact'] < forecasted['yhat_lower'], 'anomaly'] = 1
+
+    forecasted['importance'] = 0
+
+    interval_range = forecasted['yhat_upper'] - forecasted['yhat_lower']
+
+    forecasted.loc[forecasted['anomaly'] == 1, 'importance'] =\
+        (forecasted['fact'] - forecasted['yhat_upper']) / interval_range
+    forecasted.loc[forecasted['anomaly'] == -1, 'importance'] =\
+        (forecasted['yhat_lower'] - forecasted['fact']) / interval_range
+
+    return forecasted
+
+df = pd.read_csv("x_test_prophet.csv")
+m = Prophet()
+m.add_seasonality(name='50-ly', period=50, fourier_order=10)
+m.fit(df)
+future = m.make_future_dataframe(periods=1000)
+forecast = m.predict(future)
+forecast.tail()
+# fig = m.plot(forecast)
+forecasted = detect_anomalies(forecast, df)
+forecasted.to_csv("prophet.csv")
+fig = m.plot(forecast)
+
+df_y = pd.read_csv("y_test_prophet.csv")
+predict = forecasted['anomaly']
+real = df_y['label']
+
+a,b,c,d = 0,0,0,0
+for i in range(len(real)):
+    if predict[i] == 0 and real[i] == 1:
+        a += 1
+    if predict[i] == 1 and real[i] == 0:
+        b += 1
+    if predict[i] == 0 and real[i] == 0:
+        c += 1
+    if predict[i] == 1 and real[i] == 1:
+        d += 1
+
+print(a,b,c,d)
+
+plt.show()
\ No newline at end of file

 import numpy as np
 import numpy as np
 import matplotlib.pyplot as plt
 import matplotlib.pyplot as plt
+from math import sin, cos, pi
+import csv
 
 
-myX = np.loadtxt("sample.csv", delimiter=",", dtype=np.float32, encoding='UTF8', skiprows=1)
+myX = np.loadtxt("x_test.csv", delimiter=",", dtype=np.float32, encoding='UTF8', skiprows=1)
+myY = np.loadtxt("Y_test.csv", delimiter=",", dtype=np.float32, encoding='UTF8', skiprows=1)
 myX = np.expand_dims(myX, axis=0)
 myX = np.expand_dims(myX, axis=0)
-print(myX.shape)
+print(myX.shape, myY.shape)
 
 
 
 
 # #### Hyperparameters :  sigma = STD of the zoom-in/out factor
 # #### Hyperparameters :  sigma = STD of the zoom-in/out factor
 sigma = 0.1
 sigma = 0.1
-
 def DA_Scaling(X, sigma=0.1):
 def DA_Scaling(X, sigma=0.1):
     scalingFactor = np.random.normal(loc=1.0, scale=sigma, size=(1,X.shape[1])) # shape=(1,3)
     scalingFactor = np.random.normal(loc=1.0, scale=sigma, size=(1,X.shape[1])) # shape=(1,3)
     myNoise = np.matmul(np.ones((X.shape[0],1)), scalingFactor)
     myNoise = np.matmul(np.ones((X.shape[0],1)), scalingFactor)
     return X*myNoise
     return X*myNoise
 
 
+sin_function = [sin(0.04 * pi * x) for x in range(0,10000)]
+y = [i for i in range(10000)]
+
 plt.plot(list(myX)[0])
 plt.plot(list(myX)[0])
-plt.plot(list(DA_Scaling(myX, sigma))[0])
+
+for i in range(10000):
+    if myY[i] == 1:
+        plt.vlines(x=i, ymin=-1.5, ymax=myX[0][i], color='red')
+
+# plt.plot(sin_function)
+# plt.plot(list(myY))
+# plt.plot(list(DA_Scaling(myX, sigma))[0])
+# plt.legend(["original", "scaling"])
 plt.xlabel("Time")
 plt.xlabel("Time")
 plt.ylabel("Data")
 plt.ylabel("Data")
-plt.legend(["original", "scaling"])
+
 plt.show()
 plt.show()
\ No newline at end of file